@intlayer/docs 8.6.1 → 8.6.10

package/docs/fr/cli/init.md

@@ -2,7 +2,7 @@
 createdAt: 2025-12-30
 updatedAt: 2025-12-30
 title: Initialiser Intlayer
-description: Apprenez comment initialiser Intlayer dans votre projet.
+description: Apprenez à initialiser Intlayer dans votre projet.
 keywords:
   - Initialiser
   - CLI
@@ -14,6 +14,9 @@ slugs:
   - cli
   - init
 history:
+  - version: 8.6.4
+    date: 2026-03-31
+    changes: "Ajout de l'option --no-gitignore"
   - version: 7.5.9
     date: 2025-12-30
     changes: "Ajout de la commande init"
@@ -25,38 +28,39 @@ history:
 npx intlayer init
 ```
 
-La commande `init` configure automatiquement Intlayer dans votre projet en créant et en paramétrant les fichiers et réglages nécessaires. C'est la méthode recommandée pour commencer avec Intlayer.
+La commande `init` configure automatiquement Intlayer dans votre projet en paramétrant les fichiers et réglages nécessaires. C'est le moyen recommandé pour commencer avec Intlayer.
 
-## Alias:
+## Alias :
 
 - `npx intlayer init`
 
-## Arguments:
+## Arguments :
 
-- `--project-root [projectRoot]` - Optionnel. Spécifie le répertoire racine du projet. S'il n'est pas fourni, la commande recherchera le répertoire racine du projet en partant du répertoire de travail courant.
+- `--project-root [projectRoot]` - Optionnel. Spécifiez le répertoire racine du projet. Si non fourni, la commande recherchera la racine du projet à partir du répertoire de travail actuel.
+- `--no-gitignore` - Optionnel. Ignore la mise à jour automatique du fichier `.gitignore`. Si ce drapeau est défini, `.intlayer` ne sera pas ajouté au `.gitignore`.
 
-## Ce que cela fait:
+## Ce qu'il fait :
 
-The `init` command performs the following setup tasks:
+La commande `init` effectue les tâches de configuration suivantes :
 
-1. **Valide la structure du projet** - Vérifie que vous êtes dans un répertoire de projet valide contenant un fichier `package.json`
-2. **Met à jour `.gitignore`** - Ajoute `.intlayer` à votre fichier `.gitignore` pour exclure les fichiers générés du contrôle de version
-3. **Configure TypeScript** - Met à jour tous les fichiers `tsconfig.json` pour inclure les définitions de types Intlayer (`.intlayer/**/*.ts`)
-4. **Crée le fichier de configuration** - Génère un `intlayer.config.ts` (pour les projets TypeScript) ou `intlayer.config.mjs` (pour les projets JavaScript) avec les réglages par défaut
-5. **Met à jour la config Vite** - Si un fichier de configuration Vite est détecté, ajoute l'import du plugin `vite-intlayer`
-6. **Met à jour la configuration Next.js** - Si un fichier de configuration Next.js est détecté, ajoute l'import du plugin `next-intlayer`
+1. **Valide la structure du projet** - S'assure que vous êtes dans un répertoire de projet valide avec un fichier `package.json`.
+2. **Met à jour le `.gitignore`** - Ajoute `.intlayer` à votre fichier `.gitignore` pour exclure les fichiers générés du contrôle de version (peut être ignoré avec `--no-gitignore`).
+3. **Configure TypeScript** - Met à jour tous les fichiers `tsconfig.json` pour inclure les définitions de types Intlayer (`.intlayer/**/*.ts`).
+4. **Crée le fichier de configuration** - Génère un `intlayer.config.ts` (pour les projets TypeScript) ou `intlayer.config.mjs` (pour les projets JavaScript) avec les paramètres par défaut.
+5. **Met à jour la config Vite** - Si un fichier de configuration Vite est détecté, ajoute l'importation du plugin `vite-intlayer`.
+6. **Met à jour la config Next.js** - Si un fichier de configuration Next.js est détecté, ajoute l'importation du plugin `next-intlayer`.
 
 ## Exemples :
 
-### Initialisation basique :
+### Initialisation de base :
 
 ```bash
 npx intlayer init
 ```
 
-Cela initialisera Intlayer dans le répertoire courant, en détectant automatiquement la racine du projet.
+Cela initialisera Intlayer dans le répertoire actuel, en détectant automatiquement la racine du projet.
 
-### Initialiser avec une racine de projet personnalisée :
+### Initialisation avec une racine de projet personnalisée :
 
 ```bash
 npx intlayer init --project-root ./my-project
@@ -64,21 +68,29 @@ npx intlayer init --project-root ./my-project
 
 Cela initialisera Intlayer dans le répertoire spécifié.
 
+### Initialisation sans mettre à jour le .gitignore :
+
+```bash
+npx intlayer init --no-gitignore
+```
+
+Cela configurera tous les fichiers de configuration mais ne modifiera pas votre `.gitignore`.
+
 ## Exemple de sortie :
 
 ```bash
 npx intlayer init
-Vérification de la configuration d'Intlayer...
-✓ Ajout de .intlayer à .gitignore
-✓ Mise à jour de tsconfig.json pour inclure les types intlayer
-Créé intlayer.config.ts
-✓ Import injecté dans vite.config.ts
-✓ Initialisation d'Intlayer terminée.
+Checking Intlayer configuration...
+✓ Added .intlayer to .gitignore
+✓ Updated tsconfig.json to include intlayer types
+✓ Created intlayer.config.ts
+✓ Injected import into vite.config.ts
+✓ Intlayer init setup complete.
 ```
 
 ## Remarques :
 
-- La commande est idempotente - vous pouvez l'exécuter plusieurs fois en toute sécurité. Elle sautera les étapes déjà configurées.
+- La commande est idempotente - vous pouvez l'exécuter plusieurs fois en toute sécurité. Elle ignorera les étapes déjà configurées.
 - Si un fichier de configuration existe déjà, il ne sera pas écrasé.
-- Les fichiers de configuration TypeScript sans tableau `include` (par ex., les configurations de type solution avec des références) sont ignorés.
-- La commande se terminera avec une erreur si aucun `package.json` n'est trouvé à la racine du projet.
+- Les fichiers de config TypeScript sans tableau `include` (par exemple, les configs de type solution avec des références) sont ignorés.
+- La commande s'arrêtera avec une erreur si aucun `package.json` n'est trouvé à la racine du projet.

package/docs/fr/cli/standalone.md

@@ -0,0 +1,91 @@
+---
+createdAt: 2024-08-11
+updatedAt: 2026-03-31
+title: Bundle Standalone
+description: Apprenez à créer un bundle JavaScript autonome pour le contenu de votre application.
+keywords:
+  - Standalone
+  - Bundle
+  - CLI
+  - Intlayer
+  - Editor
+  - CMS
+slugs:
+  - doc
+  - concept
+  - cli
+  - standalone
+history:
+  - version: 8.6.4
+    date: 2026-03-31
+    changes: "Initialisation de la documentation de la commande standalone"
+---
+
+# Bundle Standalone
+
+La commande `standalone` vous permet de créer un bundle JavaScript autonome contenant Intlayer et tout autre paquet spécifié. Cela est particulièrement utile pour utiliser Intlayer dans des environnements sans gestionnaire de paquets ou bundler, comme une application HTML/JS pure.
+
+Le bundle utilise [esbuild](https://esbuild.github.io/) pour combiner les paquets demandés et leurs dépendances en un seul fichier qui peut être facilement importé dans n'importe quel projet web.
+
+## Utilisation
+
+```bash
+npx intlayer standalone --packages [paquets...] [options]
+```
+
+## Options
+
+- `-o, --outfile [outfile]` - Optionnel. Le nom du fichier de sortie. Par défaut : `intlayer-bundle.js`.
+- `--packages [paquets...]` - Requis. Une liste de paquets à inclure dans le bundle (par exemple, `intlayer`, `vanilla-intlayer`).
+- `--version [version]` - Optionnel. La version des paquets à regrouper. Si non spécifiée, elle correspond par défaut à la version du CLI Intlayer.
+- `--minify` - Optionnel. Indique s'il faut minifier la sortie. Par défaut : `true`.
+- `--platform [platform]` - Optionnel. La plateforme cible pour le bundle (par exemple, `browser`, `node`). Par défaut : `browser`.
+- `--format [format]` - Optionnel. Le format de sortie du bundle (par exemple, `esm`, `cjs`, `iife`). Par défaut : `esm`.
+
+## Options Communes
+
+- `--env-file [envFile]` - Fichier d'environnement.
+- `-e, --env [env]` - Environnement.
+- `--base-dir [baseDir]` - Répertoire de base.
+- `--no-cache` - Désactiver le cache.
+- `--verbose` - Sortie verbeuse.
+
+## Exemples :
+
+### Créer un bundle pour Vanilla JS :
+
+```bash
+npx intlayer standalone --packages intlayer vanilla-intlayer --outfile intlayer.js
+```
+
+Cela créera un fichier `intlayer.js` contenant à la fois les paquets `intlayer` et `vanilla-intlayer`, minifié et au format ESM, prêt à être utilisé dans un navigateur via une balise `<script>`.
+
+### Regrouper une version spécifique :
+
+```bash
+npx intlayer standalone --packages intlayer --version 8.6.4
+```
+
+### Regrouper avec un format différent :
+
+```bash
+npx intlayer standalone --packages intlayer --format iife
+```
+
+## Ce qu'il fait :
+
+1. **Crée un environnement temporaire** - Configure un répertoire temporaire pour gérer les dépendances.
+2. **Installe les paquets** - Utilise `npm` ou `bun` (si disponible) pour installer les paquets demandés et leurs dépendances.
+3. **Génère un point d'entrée** - Crée un fichier d'entrée temporaire qui exporte tous les paquets demandés et les expose en tant que variables globales lors de l'exécution dans un navigateur.
+4. **Regroupe avec esbuild** - Utilise esbuild pour tout regrouper en un seul fichier, en appliquant la minification et le formatage demandés.
+5. **Sort le fichier** - Écrit le bundle résultant dans le chemin de sortie spécifié.
+
+## Variables Globales
+
+Lorsque le bundle est chargé dans un navigateur, il expose les paquets demandés en tant que variables globales sur l'objet `window`. Les noms des variables sont dérivés des noms des paquets (par exemple, `intlayer` devient `Intlayer`, `vanilla-intlayer` devient `VanillaIntlayer`).
+
+```javascript
+// Accéder à Intlayer depuis le bundle
+const { getLocaleName } = window.Intlayer;
+const { installIntlayer, useIntlayer } = window.VanillaIntlayer;
+```

package/docs/fr/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-03-20
+updatedAt: 2026-04-08
 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,12 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 8.7.0
+    date: 2026-04-08
+    changes: "Ajout des options `prune` et `minify` à la configuration de build"
+  - version: 8.7.0
+    date: 2026-04-03
+    changes: "Ajout de l'option `currentDomain`"
   - version: 8.4.0
     date: 2026-03-20
     changes: "Ajout de la notation d'objet par locale pour 'compiler.output' et 'dictionary.fill'"
@@ -237,6 +243,17 @@ const config: IntlayerConfig = {
         fr: "/[locale]/a-propos",
       },
     }),
+
+    /**
+     * Mappe les locales aux noms d'hôte de domaine pour le routage basé sur le domaine.
+     * Les URL pour ces locales seront absolues (ex: https://intlayer.cn/).
+     * Le domaine implique la locale, donc aucun préfixe de locale n'est ajouté au chemin.
+     * Par défaut : undefined
+     */
+    domains: {
+      en: "intlayer.org",
+      zh: "intlayer.cn",
+    },
   },
 
   /**
@@ -388,6 +405,25 @@ const config: IntlayerConfig = {
      */
     optimize: true,
 
+    /**
+     * Minifier les dictionnaires pour réduire la taille du bundle.
+     * Par défaut : true
+     *
+     * Note :
+     * - Cette option sera ignorée si `optimize` est désactivé.
+     * - Cette option sera ignorée si `editor.enabled` est vrai.
+     */
+    minify: true,
+
+    /**
+     * Purger les clés inutilisées dans les dictionnaires.
+     * Par défaut : true
+     *
+     * Note :
+     * - Cette option sera ignorée si `optimize` est désactivé.
+     */
+    purge: true,
+
     /**
      * Format de sortie pour les fichiers de dictionnaire générés.
      * Par défaut : ['cjs', 'esm']
@@ -600,12 +636,13 @@ Définit les paramètres liés à l'éditeur intégré, y compris le port du ser
 
 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). |
+| 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/`.                                                         |
 
 **Exemple de `rewrite`** :
 
@@ -909,6 +946,8 @@ Les options de build s'appliquent aux plugins `@intlayer/babel` et `@intlayer/sw
 | ----------------- | ----------------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `mode`            | Contrôle le mode du build.                                                    | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: build activé automatiquement lors du build de l'application.<br/>• `'manual'`: ne s'exécute que lorsque la commande de build est exécutée.<br/>• Peut être utilisé pour désactiver les builds de dictionnaires (ex: pour éviter l'exécution dans des environnements Node.js).                                                |
 | `optimize`        | Contrôle si le build doit être optimisé.                                      | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • Si non défini, l'optimisation est déclenchée lors du build du framework (Vite/Next.js).<br/>• `true` force l'optimisation y compris en mode dev.<br/>• `false` la désactive.<br/>• Une fois activé, remplace les appels de dictionnaire pour optimiser le chunking.<br/>• Repose sur les plugins `@intlayer/babel` et `@intlayer/swc`. |
+| `minify`          | Minifier les dictionnaires pour réduire la taille du bundle.                  | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indique si le bundle doit être minifié.<br/>• Par défaut : `true` en production.<br/>• Cette option sera ignorée si `optimize` est désactivé.<br/>• Cette option sera ignorée si `editor.enabled` est vrai.                                                                                                                            |
+| `purge`           | Purger les clés inutilisées dans les dictionnaires.                           | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indique si le bundle doit être purgé.<br/>• Par défaut : `true` en production.<br/>• Cette option sera ignorée si `optimize` est désactivé.                                                                                                                                                                                            |
 | `checkTypes`      | Indique si le build doit vérifier les types TypeScript et loguer les erreurs. | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | Peut ralentir le build.                                                                                                                                                                                                                                                                                                                  |
 | `outputFormat`    | Contrôle le format de sortie des dictionnaires.                               | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                                          |
 | `traversePattern` | Motifs définissant quels fichiers parcourir lors de l'optimisation.           | `string[]`                       | `['**/*.{tsx,ts,js,mjs,cjs,jsx,vue,svelte,svte}', '!**/node_modules/**', '!**/dist/**', '!**/.intlayer/**', '!**/*.config.*', '!**/*.test.*', '!**/*.spec.*', '!**/*.stories.*']` | `['src/**/*.{ts,tsx}', '../ui-library/**/*.{ts,tsx}', '!**/node_modules/**']` | • Limitez l'optimisation aux fichiers pertinents pour améliorer les performances de build.<br/>• Ignoré si `optimize` est désactivé.<br/>• Utilise des motifs glob.                                                                                                                                                                      |

package/docs/fr/custom_domains.md

@@ -0,0 +1,250 @@
+---
+createdAt: 2026-04-02
+updatedAt: 2026-04-02
+title: Domaines personnalisés
+description: Apprenez à configurer le routage par domaine dans Intlayer pour servir différentes locales à partir de noms d'hôte dédiés.
+keywords:
+  - Domaines personnalisés
+  - Routage par domaine
+  - Routage
+  - Internationalisation
+  - i18n
+slugs:
+  - doc
+  - concept
+  - custom_domains
+history:
+  - version: 8.5.0
+    date: 2026-04-02
+    changes: "Ajout du routage par domaine via la configuration routing.domains."
+---
+
+# Domaines personnalisés
+
+Intlayer prend en charge le routage par domaine, vous permettant de servir des locales spécifiques à partir de noms d'hôte dédiés. Par exemple, les visiteurs chinois peuvent être dirigés vers `intlayer.zh` au lieu de `intlayer.org/zh`.
+
+## Fonctionnement
+
+La carte `domains` dans `routing` associe chaque locale à un nom d'hôte. Intlayer utilise cette carte à deux endroits :
+
+1. **Génération d'URL** (`getLocalizedUrl`) : lorsque la locale cible se trouve sur un domaine _différent_ de la page actuelle, une URL absolue est retournée (ex: `https://intlayer.zh/about`). Lorsque les deux domaines correspondent, une URL relative est retournée (ex: `/fr/about`).
+2. **Proxy serveur** (Next.js & Vite) : les requêtes entrantes sont redirigées ou réécrites en fonction du domaine sur lequel elles arrivent.
+
+### Domaines exclusifs vs partagés
+
+La distinction clé est l'**exclusivité** :
+
+- **Domaine exclusif** — une seule locale correspond à ce nom d'hôte (ex: `zh → intlayer.zh`). Le domaine lui-même identifie la locale, donc aucun préfixe de locale n'est ajouté au chemin. `https://intlayer.zh/about` sert le contenu chinois.
+- **Domaine partagé** — plusieurs locales correspondent au même nom d'hôte (ex: `en` et `fr` correspondent tous deux à `intlayer.org`). Le routage standard basé sur les préfixes s'applique. `intlayer.org/fr/about` sert le contenu français.
+
+## Configuration
+
+```typescript fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [
+      Locales.ENGLISH,
+      Locales.FRENCH,
+      Locales.SPANISH,
+      Locales.CHINESE,
+    ],
+    defaultLocale: Locales.ENGLISH,
+  },
+  routing: {
+    mode: "prefix-no-default",
+    domains: {
+      // Domaine partagé — en et fr utilisent le routage par préfixe sur intlayer.org
+      en: "intlayer.org",
+      // Domaine exclusif — zh a son propre nom d'hôte, aucun préfixe /zh/ n'est nécessaire
+      zh: "intlayer.zh",
+    },
+  },
+};
+
+export default config;
+```
+
+Les locales qui ne sont pas listées dans `domains` continuent d'utiliser le routage par préfixe standard sans aucune substitution de domaine.
+
+## Génération d'URL
+
+`getLocalizedUrl` produit automatiquement le bon type d'URL en fonction du contexte d'appel.
+
+### Locale sur le même domaine (URL relative)
+
+```ts
+// Page actuelle : intlayer.org/about
+getLocalizedUrl("/about", "fr", { currentDomain: "intlayer.org" });
+// → "/fr/about"
+
+getLocalizedUrl("/about", "en", { currentDomain: "intlayer.org" });
+// → "/about"  (locale par défaut, pas de préfixe)
+```
+
+### Locale sur un domaine différent (URL absolue)
+
+```ts
+// Page actuelle : intlayer.org/about
+getLocalizedUrl("/about", "zh", { currentDomain: "intlayer.org" });
+// → "https://intlayer.zh/about"  (domaine exclusif, pas de préfixe /zh/)
+```
+
+### Service depuis le propre domaine de la locale
+
+```ts
+// Page actuelle : intlayer.zh/about
+getLocalizedUrl("/about", "zh", { currentDomain: "intlayer.zh" });
+// → "/about"  (déjà sur le bon domaine — URL relative)
+
+getLocalizedUrl("/about", "fr", { currentDomain: "intlayer.zh" });
+// → "https://intlayer.org/fr/about"  (lien inter-domaines vers intlayer.org)
+```
+
+### Auto-détection du domaine actuel
+
+`currentDomain` est facultatif. S'il est omis, `getLocalizedUrl` le résout dans cet ordre :
+
+1. Le nom d'hôte d'une URL d'entrée absolue (ex: `https://intlayer.org/about` → `intlayer.org`).
+2. `window.location.hostname` dans les environnements de navigation.
+3. Si aucun n'est disponible (SSR sans option explicite), une URL relative est retournée pour les locales du même domaine et aucune URL absolue n'est produite — c'est le repli sécurisé.
+
+```ts
+// Navigateur — window.location.hostname === 'intlayer.org'
+getLocalizedUrl("/about", "zh");
+// → "https://intlayer.zh/about"  (détecté automatiquement à partir de window)
+
+// À partir d'une URL absolue — domaine détecté automatiquement
+getLocalizedUrl("https://intlayer.org/about", "zh");
+// → "https://intlayer.zh/about"
+```
+
+### `getMultilingualUrls` avec domaines
+
+`getMultilingualUrls` appelle `getLocalizedUrl` pour chaque locale, il produit donc un mélange d'URLs relatives et absolues selon le domaine de l'appelant :
+
+```ts
+// currentDomain: 'intlayer.org'
+getMultilingualUrls("/about", { currentDomain: "intlayer.org" });
+// {
+//   en: "/about",
+//   fr: "/fr/about",
+//   es: "/es/about",
+//   zh: "https://intlayer.zh/about",
+// }
+```
+
+Ces URLs absolues sont prêtes à être utilisées dans les balises `<link rel="alternate" hreflang="...">` pour le SEO.
+
+## Comportement du Proxy
+
+### Next.js
+
+Le middleware `intlayerProxy` gère automatiquement le routage par domaine. Ajoutez-le à votre `middleware.ts` :
+
+```typescript fileName="middleware.ts"
+export { intlayerProxy as default } from "next-intlayer/proxy";
+
+export const config = {
+  matcher: "/((?!api|static|assets|robots|sitemap|.*\\..*|_next).*)",
+};
+```
+
+**Redirection** — la requête arrive sur le mauvais domaine pour un préfixe de locale donné :
+
+```
+GET intlayer.org/zh/about
+→ 301 https://intlayer.zh/about
+```
+
+**Réécriture** — la requête arrive sur le domaine exclusif de la locale sans préfixe :
+
+```
+GET intlayer.zh/about
+→ réécriture vers /zh/about  (routage interne Next.js uniquement, l'URL reste propre)
+```
+
+### Vite
+
+Le plugin Vite `intlayerProxy` applique la même logique pendant le développement :
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayerProxy } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerProxy()],
+});
+```
+
+> **Note** : en développement local, vous êtes généralement sur `localhost`, donc les redirections inter-domaines pointeront vers les domaines en direct plutôt que vers un autre port local. Utilisez une substitution dans le fichier hosts (ex: `127.0.0.1 intlayer.zh`) ou un proxy inverse si vous avez besoin de tester le routage multi-domaines localement.
+
+## Sélecteur de locale
+
+Le hook `useLocale` de `next-intlayer` gère automatiquement la navigation tenant compte du domaine. Lorsqu'un utilisateur passe à une locale sur un domaine différent, le hook effectue une navigation de page complète (`window.location.href`) au lieu d'un push du routeur côté client, car le routeur Next.js ne peut pas traverser les origines.
+
+```tsx fileName="components/LocaleSwitcher.tsx"
+"use client";
+
+import { useLocale } from "next-intlayer";
+
+export const LocaleSwitcher = () => {
+  const { availableLocales, locale, setLocale } = useLocale();
+
+  return (
+    <ul>
+      {availableLocales.map((localeEl) => (
+        <li key={localeEl}>
+          <button
+            onClick={() => setLocale(localeEl)}
+            aria-current={localeEl === locale ? "true" : undefined}
+          >
+            {l.toUpperCase()}
+          </button>
+        </li>
+      ))}
+    </ul>
+  );
+};
+```
+
+Aucune configuration supplémentaire n'est requise — `useLocale` détecte `window.location.hostname` en interne et décide entre `router.replace` (même domaine) et `window.location.href` (domaine différent).
+
+## SEO : Liens alternatifs `hreflang`
+
+Le routage par domaine est couramment utilisé avec `hreflang` pour indiquer aux moteurs de recherche quelle URL indexer pour chaque langue. Utilisez `getMultilingualUrls` pour générer l'ensemble complet des URLs alternatives :
+
+```tsx fileName="app/[locale]/layout.tsx"
+import { getMultilingualUrls } from "intlayer";
+import type { Metadata } from "next";
+
+export const generateMetadata = (): Metadata => {
+  const alternates = getMultilingualUrls("/", {
+    currentDomain: process.env.NEXT_PUBLIC_DOMAIN, // ex: "intlayer.org"
+  });
+
+  return {
+    alternates: {
+      languages: alternates,
+    },
+  };
+};
+```
+
+Cela produit :
+
+```html
+<link rel="alternate" hreflang="en" href="https://intlayer.org/" />
+<link rel="alternate" hreflang="fr" href="https://intlayer.org/fr/" />
+<link rel="alternate" hreflang="es" href="https://intlayer.org/es/" />
+<link rel="alternate" hreflang="zh" href="https://intlayer.zh/" />
+```
+
+## Utilitaires de base
+
+| Utilitaire                                        | Description                                                                                            |
+| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `getLocalizedUrl(url, locale, { currentDomain })` | Retourne une URL relative ou absolue selon que la locale cible est sur le domaine actuel ou non.       |
+| `getMultilingualUrls(url, { currentDomain })`     | Retourne une carte des URLs localisées par locale, mélangeant relatives et absolues selon les besoins. |
+| `getPrefix(locale, { domains })`                  | Retourne un préfixe vide pour les locales à domaine exclusif, sinon le préfixe normal.                 |