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

package/docs/fr/cli/login.md

@@ -78,42 +78,6 @@ bun x intlayer login --cms-url https://intlayer.org
 
 ### Options de configuration
 
-Vous pouvez également utiliser les options de configuration communes :
-
-- `--env-file <path>` : Chemin vers le fichier d'environnement
-- `-e, --env <env>` : Environnement d'exécution
-- `--base-dir <dir>` : Répertoire de base du projet
-- `--verbose` : Active la sortie détaillée (par défaut : true)
-- `--prefix <prefix>` : Préfixe pour les logs
-
-## Fonctionnement
-
-1. **Démarrage d'un serveur local** : La commande démarre un serveur HTTP local sur un port aléatoire pour recevoir les identifiants depuis le CMS
-
-Spécifiez l'URL du CMS Intlayer auquel se connecter pour l'authentification.
-
-- **Type**: `string`
-- **Par défaut**: La valeur configurée dans `intlayer.config.*` ou `https://intlayer.org`
-- **Exemple**:
-
-```bash packageManager="npm"
-npx intlayer login --cms-url https://intlayer.org
-```
-
-```bash packageManager="yarn"
-yarn intlayer login --cms-url https://intlayer.org
-```
-
-```bash packageManager="pnpm"
-pnpm intlayer login --cms-url https://intlayer.org
-```
-
-```bash packageManager="bun"
-bun x intlayer login --cms-url https://intlayer.org
-```
-
-### Options de configuration
-
 Vous pouvez également utiliser les options de configuration courantes :
 
 - `--env-file <path>` : Chemin vers le fichier d'environnement

package/docs/fr/cli/scan.md

@@ -150,10 +150,10 @@ await scan("https://example.com", {
 });
 ```
 
-Pour un accès de niveau inférieur, `scanWebsite` de `@intlayer/chokidar/scan` renvoie un objet `ScanResult` structuré :
+Pour un accès de niveau inférieur, `scanWebsite` de `@intlayer/engine/scan` renvoie un objet `ScanResult` structuré :
 
 ```ts
-import { scanWebsite } from "@intlayer/chokidar/scan";
+import { scanWebsite } from "@intlayer/engine/scan";
 
 const result = await scanWebsite("https://example.com", { deep: false });
 console.log(result.score, result.totalPageSize, result.events);

package/docs/fr/compat/i18n-js.md

@@ -0,0 +1,44 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de i18n-js vers Intlayer"
+description: "Apprenez comment migrer votre application de i18n-js vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - i18n-js
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - i18n-js
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de i18n-js vers Intlayer
+
+La transition de la bibliothèque `i18n-js` vers Intlayer est une migration hautement optimisée conçue pour décharger les grandes configurations de traductions dans le système de résolution de fichiers structuré d'Intlayer.
+
+## Ce qu'il faut faire
+
+Exécutez la commande de configuration suivante dans votre référentiel :
+
+```bash
+npx intlayer init
+```
+
+Avec `intlayer.config.ts` préparé, vous pouvez ajouter l'alias d'Intlayer à la configuration de votre bundler afin que tous les imports de `i18n-js` ciblent le package de compatibilité `@intlayer/i18n-js`.
+
+## Ce qu'il fait sous le capot
+
+`i18n-js` accède aux namespaces par le biais d'expressions comme `i18n.t('scope.key', {name})` ainsi que des fallbacks de locale et des mappings pluriels spécifiques.
+
+Sous le capot :
+
+- **Interpolation :** L'adaptateur de compatibilité analyse facilement les mappings `%{name}` dans la valeur de dictionnaire runtime ciblée.
+- **Pluralisation :** Remplace les sous-clés `one/other` et les mappe par rapport aux puissants mécanismes pluriels sous-jacents d'Intlayer (`Intl.PluralRules`), en abstrayant les mappings manuels.
+- **Locales :** Au lieu de charger des payloads monolithiques de langage au bootstrap, les dictionnaires sont servis de manière optimale en fonction de la configuration de contexte actuelle via la configuration Intlayer native.

package/docs/fr/compat/i18next.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de i18next vers Intlayer"
+description: "Apprenez comment migrer votre application Vanilla JS/TS de i18next vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - i18next
+  - vanilla
+  - javascript
+  - typescript
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de i18next vers Intlayer
+
+Pour un tutoriel détaillé étape par étape, veuillez consulter notre guide complet de [migration i18next](../migration_from_i18next_to_intlayer.md).
+
+Intlayer réplique parfaitement les caractéristiques d'exécution fondamentales de `i18next`. En utilisant le package compat, vos applications Vanilla ou modules internes peuvent continuer à exploiter la syntaxe familière.
+
+## Que faire
+
+Pour commencer, initialisez Intlayer dans votre projet :
+
+```bash
+npx intlayer init
+```
+
+Si vous utilisez Vite, incluez le plugin Intlayer pour router les imports vers `@intlayer/i18next` :
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { i18nextVitePlugin } from "@intlayer/i18next/plugin";
+
+export default defineConfig({
+  plugins: [i18nextVitePlugin()],
+});
+```
+
+## Ce qu'il fait sous le capot
+
+Le `i18nextVitePlugin` redirige les imports `i18next` vers `@intlayer/i18next`, évitant ainsi le gonflement du bundle causé par l'inclusion de fichiers JSON.
+
+Sous le capot :
+
+- **Configuration d'instance :** `createInstance` analyse correctement et applique les fallbacks de namespace tout en tirant parti du pipeline de compilation d'Intlayer pour la récupération des dictionnaires.
+- **Interpolation :** Support natif des remplacements `{{name}}` et imbrication `$t(key)` récursive.
+- **Contexte & Pluriels :** Identifie et résout les formats de suffixe comme `key_male` et `key_one`/`key_other` en évaluant par rapport à `Intl.PluralRules` standard.
+- **Retour d'objets :** Le mode `returnObjects: true` extrait de manière sécurisée les arbres des dictionnaires Intlayer.

package/docs/fr/compat/index.md

@@ -0,0 +1,51 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Adaptateurs de Compatibilité Intlayer"
+description: "Migrez votre solution i18n existante vers Intlayer sans friction en utilisant des adaptateurs de compatibilité."
+keywords:
+  - compat
+  - migration
+  - internationalization
+  - i18n
+  - Intlayer
+slugs:
+  - doc
+  - compatibility
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Adaptateurs Intlayer Compat
+
+Migrer une grande application vers une nouvelle bibliothèque d'internationalisation peut être intimidant. Pour faciliter cette transition, Intlayer fournit des **adaptateurs de compatibilité** pour les bibliothèques i18n les plus populaires de l'écosystème.
+
+Ces packages d'adaptateurs exposent la **même API publique exacte** que vos bibliothèques i18n existantes, mais délèguent tout le travail de traduction à Intlayer lors de l'exécution.
+
+## Fonctionnement
+
+Lorsque vous utilisez un adaptateur de compatibilité, vous n'avez pas besoin de réécrire les imports de votre application ou de modifier la façon dont vous utilisez vos hooks et composants de traduction. À la place, les plugins bundler d'Intlayer aliasent automatiquement vos imports existants vers les packages de compatibilité Intlayer.
+
+Par exemple, un développeur remplace `import { useTranslation } from 'react-i18next'` par `import { useTranslation } from '@intlayer/react-i18next'` (fait automatiquement via le plugin bundler), et l'application continue de fonctionner avec les traductions servies par les dictionnaires Intlayer. Les clés sont également typées par rapport à vos dictionnaires Intlayer !
+
+## Adaptateurs de compatibilité disponibles
+
+Choisissez votre librairie existante ci-dessous pour voir comment migrer sans friction :
+
+- [Vue I18n](./vue-i18n.md)
+- [Transloco](./transloco.md)
+- [React Intl](./react-intl.md)
+- [Svelte I18n](./svelte-i18n.md)
+- [React i18next](./react-i18next.md)
+- [Polyglot.js](./polyglot.md)
+- [NuxtJS I18n](./nuxtjs-i18n.md)
+- [NGX Translate](./ngx-translate.md)
+- [Next Translate](./next-translate.md)
+- [Next Intl](./next-intl.md)
+- [Next i18next](./next-i18next.md)
+- [i18next](./i18next.md)
+- [Lingui](./lingui.md)
+- [I18n-js](./i18n-js.md)

package/docs/fr/compat/lingui.md

@@ -0,0 +1,44 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de Lingui vers Intlayer"
+description: "Apprenez à migrer votre application de Lingui vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - lingui
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - lingui
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de Lingui à Intlayer
+
+Si votre projet s'appuie actuellement sur la compilation basée sur les macros de Lingui, la transition vers Intlayer vous permet de maintenir vos puissants flux de travail avec macros tout en les soutenant nativement avec la stratégie de compilation JSON d'Intlayer.
+
+## À faire
+
+Pour commencer, initialisez Intlayer dans votre projet :
+
+```bash
+npx intlayer init
+```
+
+Cela crée votre `intlayer.config.ts`. Assurez-vous de conserver `@lingui/babel-plugin-lingui-macro` / `@lingui/swc-plugin` dans votre étape de build pour s'exécuter _avant_ le compilateur Intlayer. Ensuite, utilisez l'alias du plugin bundler pour router `@lingui/core` et `@lingui/react` vers `@intlayer/lingui`.
+
+## Ce qu'il fait sous le capot
+
+Lingui utilise des macros (comme `` t`Hello ${name}` `` et `<Trans>`) qui sont compilées en appels runtime comme `i18n._(id, values)`.
+
+Sous le capot :
+
+- **Macros :** Elles se compilent exactement comme avant, garantissant aucune perturbation dans votre syntaxe source.
+- **Runtime translation :** L'alias `i18n._()` utilise les dictionnaires Intlayer. Les IDs explicitement nommés et les IDs hachés sont entièrement mappés en utilisant les plugins de synchronisation `.po` d'Intlayer pour agréger et élaguer les clés de manière sécurisée.
+- **Capacités ICU :** Le support pour la pluralisation, la sélection et les variantes ICU reste robuste grâce au parser ICU unifié d'Intlayer, garantissant des résultats de rendu identiques.

package/docs/fr/compat/next-i18next.md

@@ -0,0 +1,57 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de next-i18next vers Intlayer"
+description: "Apprenez à migrer votre application Next.js de next-i18next vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - next-i18next
+  - nextjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - next-i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de next-i18next vers Intlayer
+
+Pour un tutoriel complet et détaillé étape par étape, veuillez consulter notre [Guide de migration next-i18next](../migration_from_next-i18next_to_intlayer.md).
+
+Intlayer gère toutes les implémentations Next.js Pages Router et App Router de manière transparente. L'utilisation de l'adaptateur vous permet de migrer votre implémentation `next-i18next` sans réécriture de code.
+
+## À faire
+
+Pour commencer, exécutez :
+
+```bash
+npx intlayer init
+```
+
+Cela crée le fichier de configuration Intlayer requis. Pour intégrer Intlayer en arrière-plan, mettez à jour votre `next.config.ts` :
+
+```typescript fileName="next.config.ts"
+import type { NextConfig } from "next";
+import { createNextI18nPlugin } from "@intlayer/next-i18next/plugin";
+
+const withIntlayer = createNextI18nPlugin();
+
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+## Ce qu'il fait sous le capot
+
+Le `createNextI18nPlugin` compose le comportement natif de Next.js aux côtés du plugin core `next-intlayer`, en injectant tous les aliases Webpack/Turbopack requis pour `next-i18next`, `react-i18next`, et `i18next`.
+
+Sous le capot :
+
+- **`serverSideTranslations` & `appWithTranslation` :** Ils fonctionnent désormais comme des wrappers pour les loaders internes d'Intlayer, contournant l'injection statique JSON volumineux.
+- **Client hooks :** Délègue immédiatement à `@intlayer/react-i18next` en conservant toutes les fonctionnalités de formatage, pluriels et espaces de noms imbriqués.

package/docs/fr/compat/next-intl.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de next-intl vers Intlayer"
+description: "Apprenez comment migrer votre application Next.js de next-intl vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - next-intl
+  - nextjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - next-intl
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de next-intl vers Intlayer
+
+Pour un tutoriel complet et détaillé étape par étape, consultez notre [Guide de migration next-intl](../migration_from_next-intl_to_intlayer.md).
+
+Migrer de `next-intl` vers Intlayer vous permet de maintenir votre routage d'application et votre syntaxe complètement inchangés.
+
+## Ce qu'il faut faire
+
+Exécutez la commande suivante dans votre repository :
+
+```bash
+npx intlayer init
+```
+
+Cela créera un fichier `intlayer.config.ts`. Dans votre `next.config.ts`, utilisez le wrapper du plugin pour injecter de manière transparente les aliases `next-intl` vers `@intlayer/next-intl`.
+
+```typescript fileName="next.config.ts"
+import type { NextConfig } from "next";
+import { createNextIntlPlugin } from "@intlayer/next-intl/plugin";
+
+const withIntlayer = createNextIntlPlugin();
+
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+## Ce qu'il fait sous le capot
+
+Le wrapper bundler remplace les traductions, mais **laisse les fonctionnalités de `next-intl/navigation` intactes** (par exemple `Link`, `redirect`, `usePathname`).
+
+Sous le capot :
+
+- **ICU runtime :** Les pluriels (`=0`, `one`, `other`), select/selectordinal, les arguments `#`, et les args formatés (`{ts, date, long}`) fonctionnent correctement en utilisant le resolver partagé `resolveMessage(..., 'icu')`.
+- **`useTranslations()` & `getTranslations()` :** Les appels de scope nu extraient le premier segment de clé comme l'identifiant de dictionnaire correct. Les namespaces imbriqués se divisent gracieusement en chemins de dictionnaire et préfixes.
+- **Rich formatting :** Both `t.rich()` et `t.markup()` sont entièrement implémentés nativement, convertissant les nœuds de type HTML en chunks React rendus.
+- **`useFormatter` :** `relativeTime`, `list`, `dateTimeRange`, et les formats nommés de la configuration se connectent aux formatters natifs `Intl` du cœur.

package/docs/fr/compat/next-translate.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de Next Translate vers Intlayer"
+description: "Apprenez comment migrer votre application Next.js de next-translate vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - next-translate
+  - nextjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - next-translate
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de Next Translate vers Intlayer
+
+La migration de `next-translate` vers Intlayer est un remplacement quasi direct qui conserve votre syntaxe et vos balises existantes.
+
+## Ce qu'il faut faire
+
+Initialisez Intlayer dans votre projet :
+
+```bash
+npx intlayer init
+```
+
+Le CLI va générer votre configuration. Vous pouvez ensuite appliquer le plugin Intlayer dans votre `next.config.ts`, qui injecte des alias de sous-chemin au moment de la compilation en mappant `next-translate/useTranslation` vers `@intlayer/next-translate`.
+
+## Ce qu'il fait sous le capot
+
+`next-translate` fournit des hooks comme `useTranslation('ns')`, `t('ns:key.path')`, et le composant `<Trans>`.
+
+Sous le capot :
+
+- **Interpolation & Plurals :** Il s'appuie étroitement sur le comportement de l'adaptateur `react-i18next`. Les placeholders `{{var}}` et la pluralisation mappée à partir de suffixes comme `key_0`, `key_one` et `key_other` sont traités dynamiquement.
+- **Composant `<Trans>` :** Directement supporté pour l'analyse des tags de type HTML aux côtés d'une prop `components` basée sur un tableau.
+- **Namespaces :** L'aliasing de sous-chemin s'assure que votre `useTranslation` référence les namespaces de dictionnaire internes corrects sans modification manuelle.

package/docs/fr/compat/ngx-translate.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de NGX-Translate vers Intlayer"
+description: "Apprenez à migrer votre application Angular de ngx-translate vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - ngx-translate
+  - angular
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - ngx-translate
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de NGX-Translate vers Intlayer
+
+Migrer votre application Angular de `ngx-translate` vers Intlayer est facile avec l'adaptateur de compatibilité, vous permettant de contourner le besoin de réécrire tous vos templates.
+
+## À faire
+
+Commencez par exécuter :
+
+```bash
+npx intlayer init
+```
+
+Cela configure le fichier `intlayer.config.ts`. Remplacez vos configurations `TranslateModule.forRoot()` et les alias d'importation pour pointer vers `@intlayer/ngx-translate`.
+
+## Ce qu'il fait sous le capot
+
+`ngx-translate` utilise `TranslateService` (`instant`, `get`, `stream`) aux côtés du pipe `{{ 'KEY' | translate:params }}` et de la directive `[translate]`.
+
+Sous le capot :
+
+- **Services :** `TranslateService` enveloppe `getIntlayer` et un observable de locale, fournissant exactement les mêmes méthodes.
+- **Pipes & Directives :** Réimplémentés pour résoudre directement contre les dictionnaires Intlayer.
+- **Loaders :** Les configurations de `TranslateHttpLoader` sont converties en stubs d'avertissement car Intlayer résout et regroupe intrinsèquement vos dictionnaires au moment de la compilation (ou via des imports dynamiques standard), éliminant complètement le besoin de loaders HTTP.

package/docs/fr/compat/nuxtjs-i18n.md

@@ -0,0 +1,46 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de NuxtJS I18n vers Intlayer"
+description: "Apprenez comment migrer votre application Nuxt.js de @nuxtjs/i18n vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - nuxtjs-i18n
+  - nuxt
+  - vue
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - nuxtjs-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de NuxtJS I18n vers Intlayer
+
+Migrer votre application Nuxt de `@nuxtjs/i18n` vers Intlayer est un processus transparent en utilisant le module adaptateur Nuxt.
+
+## À faire
+
+Pour initialiser le projet, exécutez :
+
+```bash
+npx intlayer init
+```
+
+Cela configurera `intlayer.config.ts`. Ensuite, ajoutez le module Intlayer Nuxt (par exemple `@intlayer/nuxt-i18n`) dans le tableau modules de votre `nuxt.config.ts`. Cela applique automatiquement la configuration de compatibilité pour votre application.
+
+## Ce qu'il fait sous le capot
+
+`@nuxtjs/i18n` wraps `vue-i18n` tout en fournissant des composables de routage spécifiques à Nuxt (`useLocalePath`, `useSwitchLocalePath`, `<NuxtLinkLocale>`).
+
+Sous le capot :
+
+- **Translations :** S'appuie nativement sur la couche de compatibilité `@intlayer/vue-i18n` pour toutes les tâches de traduction de chaînes (supportant pleinement les formats `vue-i18n`, les pluriels avec pipe, et la réactivité).
+- **Routing :** Reproduit les composables de routage en utilisant les helpers d'URL localisées d'Intlayer.
+- **Configuration :** Lit les paramètres `availableLocales` et par défaut directement de votre `intlayer.config.ts` pour coordonner automatiquement les pages Nuxt.

package/docs/fr/compat/polyglot.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de Polyglot.js vers Intlayer"
+description: "Apprenez à migrer de Polyglot.js vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - polyglot
+  - airbnb
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - polyglot
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de Polyglot.js vers Intlayer
+
+Si vous utilisez Polyglot.js d'Airbnb, la migration vers Intlayer est extrêmement simple en utilisant la couche de compatibilité.
+
+## Que faire
+
+Exécutez simplement la commande d'initialisation dans votre projet :
+
+```bash
+npx intlayer init
+```
+
+Cela génère `intlayer.config.ts`. Vous pouvez ensuite utiliser l'alias du plugin bundler pour rediriger de manière transparente les importations Polyglot vers `@intlayer/polyglot`.
+
+## Ce qu'il fait sous le capot
+
+La syntaxe de Polyglot.js s'appuie généralement sur `polyglot.t('key', {name})` avec des interpolations `%{name}` et des pluriels `smart_count` séparés par `"singular |||| plural"`.
+
+Sous le capot :
+
+- **Interpolation :** La couche de compatibilité gère les espaces réservés `%{var}` de manière native.
+- **Pluriels :** La chaîne est divisée à `||||` et évaluée par rapport aux `Intl.PluralRules` natifs selon la locale active, en miroir de l'ordre des buckets propre de Polyglot par locale.
+- **Dictionnaires :** Vous évitez d'avoir à fournir d'énormes configurations JSON à `new Polyglot()` – Intlayer gère les dictionnaires dynamiquement et les élague automatiquement.

package/docs/fr/compat/react-i18next.md

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de react-i18next vers Intlayer"
+description: "Apprenez à migrer votre application React de react-i18next vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - react-i18next
+  - i18next
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de react-i18next vers Intlayer
+
+Pour un tutoriel complet et détaillé étape par étape, consultez notre [Guide de Migration react-i18next](../migration_from_react-i18next_to_intlayer.md).
+
+L'adaptateur de compatibilité d'Intlayer vous permet de migrer depuis `react-i18next` sans aucune modification de vos importations de code source.
+
+## Ce qu'il faut faire
+
+Pour initialiser le projet, exécutez :
+
+```bash
+npx intlayer init
+```
+
+Lors de l'initialisation, Intlayer installera `@intlayer/react-i18next` et créera `intlayer.config.ts`. Dans votre bundler (comme Vite), appliquez le plugin Intlayer :
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { reactI18nextVitePlugin } from "@intlayer/react-i18next/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactI18nextVitePlugin()],
+});
+```
+
+## Fonctionnement interne
+
+Le `reactI18nextVitePlugin` encapsule le plugin `vite-intlayer` principal et injecte des alias de résolution pour `react-i18next` et `i18next`, les redirigeant vers `@intlayer/react-i18next` et `@intlayer/i18next`.
+
+Fonctionnement interne :
+
+- **`useTranslation` & `withTranslation`:** Réécrit pour utiliser les hooks natifs d'Intlayer, vous donnant l'autocomplétion TypeScript automatique pour vos clés de dictionnaire. Il prend en charge les namespaces de manière transparente (ex. `t('namespace:key')`).
+- **Plurals & Context:** Gère la pluralisation basée sur des suffixes d'i18next (`key_one`, `key_other`) en utilisant `Intl.PluralRules` natif et les suffixes de contexte (`key_male`).
+- **`<Trans>` Component:** Ré-implémenté pour supporter la prop `components`, les formes objet et tableau, et les tags numérotés `<1>...</1>` mappant directement à vos nœuds React.
+- **`i18n` instance:** Résout les clés directement depuis Intlayer sans récupérer de gros fichiers JSON, ce qui réduit considérablement la taille du bundle.

package/docs/fr/compat/react-intl.md

@@ -0,0 +1,55 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrer de React Intl vers Intlayer"
+description: "Apprenez comment migrer votre application React de react-intl vers Intlayer en utilisant l'adaptateur de compatibilité."
+keywords:
+  - react-intl
+  - formatjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-intl
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrer de React Intl à Intlayer
+
+Si votre application React utilise `react-intl` (FormatJS), la transition vers Intlayer est très facile. Notre couche de compatibilité gère sans effort ICU MessageFormat et tous les composants `Formatted*` existants.
+
+## À faire
+
+Commencez par exécuter la commande d'initialisation dans votre projet :
+
+```bash
+npx intlayer init
+```
+
+Ensuite, configurez le plugin Intlayer Vite ou Next.js dans votre configuration. Ce plugin injecte des alias au moment de la construction pour rediriger les imports `react-intl` vers `@intlayer/react-intl`.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import reactIntlVitePlugin from "@intlayer/react-intl/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactIntlVitePlugin()],
+});
+```
+
+## Ce qu'il fait sous le capot
+
+Le plugin bundler alias `react-intl` à `@intlayer/react-intl`. Au lieu d'analyser manuellement de grands fichiers JSON et d'envelopper votre app dans un `IntlProvider`, le plugin Intlayer extrait statiquement les clés et utilise les dictionnaires Intlayer au runtime.
+
+Sous le capot :
+
+- **ICU MessageFormat:** Intlayer utilise le resolver `resolveMessage(..., 'icu')` qui supporte complètement les pluralisations ICU, la sélection, le formatage des dates/nombres, et les rich text tags nativement.
+- **Method & JSX callers:** `intl.formatMessage({ id: 'a.b' })` et `<FormattedMessage id="a.b">` sont identifiés par les plugins compilateurs Intlayer (`@intlayer/babel` / `@intlayer/swc`), convertissant les clés en pointillés plats de sorte que le premier segment se résout correctement à la clé du dictionnaire Intlayer.
+- **Formatters:** `<FormattedNumber>`, `<FormattedDate>`, etc., sont relayés aux `core/formatters` natifs en utilisant `Intl`.