@intlayer/docs 9.4.0-canary.0 → 9.4.1

package/docs/fr/intlayer_with_vite+lit.md

@@ -109,6 +109,8 @@ Bien plus qu'une simple solution i18n, Intlayer propose un **[éditeur visuel](h
 
 ---
 
+Voir [Application Template](https://github.com/aymericzip/intlayer-vite-lit-template) sur GitHub.
+
 ## Guide étape par étape pour configurer Intlayer dans une application Vite et Lit
 
 <Steps>
@@ -478,6 +480,8 @@ Tout d'abord, ajoutez `intlayerProxy` à votre configuration Vite :
 
 > Notez que pour utiliser `intlayerProxy` en production, vous devez déplacer `vite-intlayer` de `devDependencies` vers `dependencies`.
 
+> Depuis Intlayer v9, `intlayerProxy()` est intégré directement dans le plugin `intlayer()` et activé par défaut via l'option `routing.enableProxy` (`true` par défaut). Son enregistrement séparé comme montré ci-dessous est désormais optionnel — il est conservé pour la compatibilité rétroactive et pour les configurations qui nécessitent de contrôler l'ordre des plugins. Définissez `routing.enableProxy: false` pour désactiver cette fonctionnalité. Consultez les [notes de version v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/fr/intlayer_with_vite+preact.md

@@ -61,10 +61,6 @@ author: aymericzip
   </Tab>
 </Tabs>
 
-> Ce package est en cours de développement. Consultez le [problème](https://github.com/aymericzip/intlayer/issues/118) pour plus d'informations. Montrez votre intérêt pour Intlayer avec Preact en aimant ce problème.
-
-Voir le [Modèle d'application](https://github.com/aymericzip/intlayer-vite-preact-template) sur GitHub.
-
 ## Table des matières
 
 <TOC/>
@@ -122,6 +118,8 @@ Bien plus qu'une simple solution i18n, Intlayer propose un **[éditeur visuel](h
 
 ## Guide étape par étape pour configurer Intlayer dans une application Vite et Preact
 
+Voir [Application Template](https://github.com/aymericzip/intlayer-vite-preact-template) sur GitHub.
+
 <Steps>
 
 <Step number={1} title="Installer les dépendances">
@@ -516,6 +514,30 @@ const App: FunctionalComponent = () => (
 export default App;
 ```
 
+En parallèle, vous pouvez également utiliser `intlayerProxy` pour ajouter du routage côté serveur à votre application. Ce plugin détectera automatiquement la locale actuelle en fonction de l'URL et définira le cookie de locale approprié. Si aucune locale n'est spécifiée, le plugin déterminera la locale la plus appropriée en fonction des préférences linguistiques du navigateur de l'utilisateur. Si aucune locale n'est détectée, il redirigera vers la locale par défaut.
+
+> Notez que pour utiliser `intlayerProxy` en production, vous devez passer le package `vite-intlayer` de `devDependencies` à `dependencies`.
+
+> Depuis Intlayer v9, `intlayerProxy()` est intégré directement dans le plugin `intlayer()` et activé par défaut via l'option `routing.enableProxy` (`true` par défaut). Son enregistrement séparé comme montré ci-dessous est maintenant optionnel — il est conservé pour la compatibilité rétroactive et pour les configurations qui ont besoin de contrôler l'ordre des plugins. Définissez `routing.enableProxy: false` pour refuser. Consultez les [notes de version v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+
+```typescript {3,7} fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+import preact from "@preact/preset-vite";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [
+    preact(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
 </Step>
 
 <Step number={8} title="Changer l'URL lorsque la langue change" isOptional={true}>
@@ -592,6 +614,10 @@ export default LocaleSwitcher;
 >
 > > - [Hook `useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/useLocale.md) (l'API est similaire pour `preact-intlayer`)> - [Hook `getLocaleName`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getLocaleName.md)> - [Hook `getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getLocalizedUrl.md)> - [Hook `getHTMLTextDir`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getHTMLTextDir.md)> - [Attribut `hreflang`](https://developers.google.com/search/docs/specialty/international/localized-versions?hl=fr)> - [Attribut `lang`](https://developer.mozilla.org/fr/docs/Web/HTML/Global_attributes/lang)> - [Attribut `dir`](https://developer.mozilla.org/fr/docs/Web/HTML/Global_attributes/dir)> - [Attribut `aria-current`](https://developer.mozilla.org/fr/docs/Web/Accessibility/ARIA/Attributes/aria-current)> - [API Popover](https://developer.mozilla.org/fr/docs/Web/API/Popover_API)
 
+Voici l'**Étape 9** mise à jour avec des explications ajoutées et des exemples de code affinés :
+
+---
+
 </Step>
 
 <Step number={9} title="Modifier les attributs de langue et de direction du HTML" isOptional={true}>
@@ -661,6 +687,12 @@ const App: FunctionalComponent = () => (
 export default App;
 ```
 
+En appliquant ces modifications, votre application va :
+
+- Assurez-vous que l'attribut **langue** (`lang`) reflète correctement la locale actuelle, ce qui est important pour le SEO et le comportement du navigateur.
+- Ajustez la **direction du texte** (`dir`) en fonction de la locale, améliorant la lisibilité et l'utilisabilité pour les langues avec des ordres de lecture différents.
+- Fournissez une expérience plus **accessible**, car les technologies d'assistance dépendent de ces attributs pour fonctionner de manière optimale.
+
 </Step>
 
 <Step number={10} title="Création d'un Composant de Lien Localisé" isOptional={true}>

package/docs/fr/intlayer_with_vite+react.md

@@ -501,6 +501,8 @@ En parallèle, vous pouvez également utiliser le `intlayerProxy` pour ajouter u
 
 > Notez que pour utiliser le `intlayerProxy` en production, vous devez déplacer le paquet `vite-intlayer` de `devDependencies` vers `dependencies`.
 
+> Depuis Intlayer v9, `intlayerProxy()` est intégré directement dans le plugin `intlayer()` et activé par défaut via l'option `routing.enableProxy` (`true` par défaut). L'enregistrement séparé comme montré ci-dessous est maintenant optionnel — il est conservé pour la compatibilité rétroactive et pour les configurations qui nécessitent de contrôler l'ordre des plugins. Définissez `routing.enableProxy: false` pour refuser. Voir les [notes de version v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react-swc";

package/docs/fr/intlayer_with_vite+react_compiler.md

@@ -232,6 +232,8 @@ export default defineConfig({
 
 > Le plugin Vite `intlayerCompiler()` est utilisé pour extraire le contenu des composants et écrire des fichiers `.content`.
 
+> Depuis Intlayer v9, le compilateur est intégré directement dans le plugin `intlayer()` et s'active automatiquement une fois que `compiler.enabled` est défini avec un chemin `compiler.output`. L'enregistrement de `intlayerCompiler()` séparément comme indiqué ci-dessous est maintenant optionnel — il se déduplique lui-même s'il est également ajouté. Consultez les [notes de version v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+
 </Step>
 
 <Step number={4} title="Compiler votre code">

package/docs/fr/intlayer_with_vite+solid.md

@@ -46,6 +46,17 @@ author: aymericzip
   loading="lazy"
 />
 
+  </Tab>
+  <Tab label="Démo" value="demo">
+
+<iframe
+  src="https://intlayer-vite-solid.vercel.app"
+  className="m-auto overflow-hidden rounded-lg border-0 max-md:size-full max-md:h-[700px] md:aspect-16/9 md:w-full"
+  title="Démo Intlayer Vite + Solid Template"
+  sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
+  loading="lazy"
+/>
+
   </Tab>
 </Tabs>
 
@@ -53,10 +64,6 @@ author: aymericzip
 
 <TOC/>
 
-> Ce paquet est en cours de développement. Consultez le [problème](https://github.com/aymericzip/intlayer/issues/117) pour plus d'informations. Montrez votre intérêt pour Intlayer pour Solid en aimant ce problème.
-
-<!-- Voir le [Modèle d'application](https://github.com/aymericzip/intlayer-solid-template) sur GitHub. -->
-
 ## Pourquoi Intlayer plutôt que des alternatives ?
 
 Par rapport aux solutions principales telles que `@solid-primitives/i18n` ou `i18next`, Intlayer est une solution dotée d'optimisations intégrées telles que :
@@ -242,8 +249,6 @@ export default appContent;
 
 > Vos déclarations de contenu peuvent être définies n'importe où dans votre application dès qu'elles sont incluses dans le répertoire `contentDir` (par défaut, `./src`). Et correspondent à l'extension de fichier de déclaration de contenu (par défaut, `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
 
-> Pour plus de détails, référez-vous à la [documentation sur la déclaration de contenu](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/content_file.md).
-
 </Step>
 
 <Step number={5} title="Utiliser Intlayer dans votre code">
@@ -491,29 +496,10 @@ export const Link: ParentComponent<AnchorProps> = (props) => {
 };
 ```
 
-</Step>
-
 <Step number={11} title="Rendre le Markdown" isOptional={true}>
 
 Intlayer prend en charge le rendu du contenu Markdown directement dans votre application Solid en utilisant son propre analyseur interne. Par défaut, Markdown est traité comme du texte brut. Pour le rendre en HTML riche, enveloppez votre application avec le `MarkdownProvider`.
 
-```tsx fileName="src/index.tsx"
-import { render } from "solid-js/web";
-import { MarkdownProvider } from "solid-intlayer/markdown";
-import App from "./App";
-
-const root = document.getElementById("root");
-
-render(
-  () => (
-    <MarkdownProvider>
-      <App />
-    </MarkdownProvider>
-  ),
-  root!
-);
-```
-
 Ensuite, vous pouvez l'utiliser dans vos composants :
 
 ```tsx
@@ -738,19 +724,8 @@ Pour améliorer votre expérience de développement avec Intlayer, vous pouvez i
 
 [Installer depuis le Marketplace VS Code](https://marketplace.visualstudio.com/items?itemName=intlayer.intlayer-vs-code-extension)
 
-Cette extension offre :
-
-- **Autocomplétion** pour les clés de traduction.
-- **Détection d'erreurs en temps réel** pour les traductions manquantes.
-- **Aperçus en ligne** du contenu traduit.
-- **Actions rapides** pour créer et mettre à jour facilement les traductions.
-
-Pour plus de détails sur l'utilisation de l'extension, consultez la [documentation de l'extension Intlayer pour VS Code](https://intlayer.org/doc/vs-code-extension).
-
 ---
 
 ### Aller plus loin
 
 Pour aller plus loin, vous pouvez implémenter l’[éditeur visuel](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_visual_editor.md) ou externaliser votre contenu en utilisant le [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_CMS.md).
-
----

package/docs/fr/intlayer_with_vite+svelte.md

@@ -455,6 +455,8 @@ En parallèle, vous pouvez également utiliser le `intlayerProxy` pour ajouter u
 
 > Notez que pour utiliser le `intlayerProxy` en production, vous devez déplacer le paquet `vite-intlayer` de `devDependencies` vers `dependencies`.
 
+> Depuis Intlayer v9, `intlayerProxy()` est directement intégré au plugin `intlayer()` et activé par défaut via l'option `routing.enableProxy` (`true` par défaut). Son enregistrement séparé comme indiqué ci-dessous est désormais optionnel — il est conservé pour la compatibilité rétroactive et pour les configurations qui ont besoin de contrôler l'ordre des plugins. Définissez `routing.enableProxy: false` pour désactiver cette fonctionnalité. Voir les [notes de version v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { svelte } from "@sveltejs/vite-plugin-svelte";

package/docs/fr/intlayer_with_vite+vanilla.md

@@ -470,6 +470,8 @@ Tout d'abord, ajoutez `intlayerProxy` à votre config Vite :
 
 > Notez que pour utiliser `intlayerProxy` en production, vous devez déplacer `vite-intlayer` de `devDependencies` vers `dependencies`.
 
+> Depuis Intlayer v9, `intlayerProxy()` est fourni directement dans le plugin `intlayer()` et activé par défaut via l'option `routing.enableProxy` (`true` par défaut). L'enregistrement séparé comme montré ci-dessous est maintenant optionnel — il est conservé pour la compatibilité rétroactive et pour les configurations qui ont besoin de contrôler l'ordre des plugins. Définissez `routing.enableProxy: false` pour désactiver cette fonctionnalité. Consultez les [notes de version v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/fr/intlayer_with_vite+vue.md

@@ -357,6 +357,13 @@ app.use(intlayer);
 app.mount("#app");
 ```
 
+> Vous pouvez aussi appeler `installIntlayer(app)` directement comme une fonction si vous préférez :
+>
+> ```javascript
+> import { intlayer } from "vue-intlayer";
+> app.use(intlayer);
+> ```
+
 Accédez à vos dictionnaires de contenu dans toute votre application en créant un composant Vue principal et en utilisant les composables `useIntlayer` :
 
 ```vue fileName="src/HelloWord.vue"
@@ -410,6 +417,8 @@ const countRef = ref(0);
 </template>
 ```
 
+> Si votre application existe déjà, vous pouvez utiliser le [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/compiler.md), ainsi que la [commande extract](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/cli/extract.md), pour transformer des milliers de composants en une seconde.
+
 #### Accéder au contenu dans Intlayer
 
 Intlayer propose différentes API pour accéder à votre contenu :
@@ -428,8 +437,6 @@ Intlayer propose différentes API pour accéder à votre contenu :
   - Utilisez `const content = useIntlayer("myContent");` et `{{ content.myContent }}` / `<content.myContent />`.
   - Ou utilisez `const { myContent } = useIntlayer(\"myContent\");` et `{{ myContent }}` / `<myContent/>` pour déstructurer le contenu.
 
-> Si votre application existe déjà, vous pouvez utiliser le [Compilateur Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/compiler.md), ainsi que la [commande d'extraction](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/cli/extract.md), pour transformer des milliers de composants en une seconde.
-
 </Step>
 
 <Step number={6} title="Changer la langue de votre contenu" isOptional={true}>
@@ -617,6 +624,10 @@ import LocaleSwitcher from "@components/LocaleSwitcher.vue";
 
 Parallèlement, vous pouvez également utiliser le `intlayerProxy` pour ajouter un routage côté serveur à votre application. Ce plugin détectera automatiquement la locale actuelle en fonction de l'URL et définira le cookie de locale approprié. Si aucune locale n'est spécifiée, le plugin déterminera la locale la plus appropriée en fonction des préférences linguistiques du navigateur de l'utilisateur. Si aucune locale n'est détectée, il redirigera vers la locale par défaut.
 
+> Notez que pour utiliser `intlayerProxy` en production, vous devez basculer le package `vite-intlayer` de `devDependencies` à `dependencies`.
+
+> Depuis Intlayer v9, `intlayerProxy()` est fourni directement dans le plugin `intlayer()` et activé par défaut via l'option `routing.enableProxy` (`true` par défaut). L'enregistrement séparé comme indiqué ci-dessous est désormais optionnel — il est conservé pour la compatibilité rétroactive et pour les configurations qui ont besoin de contrôler l'ordre des plugins. Définissez `routing.enableProxy: false` pour refuser. Consultez les [notes de version v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
@@ -1118,3 +1129,5 @@ Pour plus de détails sur l'utilisation de l'extension, consultez la [documentat
 ### Aller plus loin
 
 Pour aller plus loin, vous pouvez implémenter l’[éditeur visuel](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_visual_editor.md) ou externaliser votre contenu en utilisant le [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_CMS.md).
+
+Please share the content blocks.---

package/docs/fr/live-sync.md

@@ -42,8 +42,6 @@ La synchronisation en direct permet à votre application de refléter les modifi
 
 ## Activer la synchronisation en direct
 
-> La synchronisation en direct nécessite une connexion continue au serveur et est disponible dans le plan entreprise.
-
 Activez la synchronisation en direct en mettant à jour votre configuration Intlayer :
 
 ```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
@@ -85,6 +83,19 @@ export default config;
 
 Démarrez le serveur Live Sync pour envelopper votre application :
 
+Exemple utilisant un serveur autonome :
+
+```json5 fileName="package.json"
+{
+  "scripts": {
+    // ... autres scripts
+    "live:start": "npx intlayer live",
+  },
+}
+```
+
+Vous pouvez également utiliser votre serveur d'application en parallèle en utilisant l'argument `--process`.
+
 Exemple avec Next.js :
 
 ```json5 fileName="package.json"

package/docs/fr/packages/elysia-intlayer/exports.md

@@ -0,0 +1,134 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Documentation du package elysia-intlayer
+description: Plugin Elysia pour Intlayer, fournissant des fonctions de traduction et la détection de la locale.
+keywords:
+  - elysia-intlayer
+  - elysia
+  - plugin
+  - internationalization
+  - i18n
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - exports
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Documentation unifiée pour tous les exports"
+author: aymericzip
+---
+
+# Package elysia-intlayer
+
+Le package `elysia-intlayer` fournit un plugin pour les applications Elysia afin de gérer l'internationalisation. Il détecte la locale de l'utilisateur et injecte un objet `intlayer` dans le contexte de route.
+
+## Installation
+
+```bash packageManager="npm"
+npm install intlayer elysia-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add intlayer elysia-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add intlayer elysia-intlayer
+```
+
+```bash packageManager="bun"
+bun add intlayer elysia-intlayer
+```
+
+> `elysia` est une peer dependency (`>=1.0.0`). Elysia cible le runtime **Bun**.
+
+## Exports
+
+### Plugin
+
+Importer :
+
+```ts
+import { intlayer } from "elysia-intlayer";
+```
+
+| Fonction   | Description                                                                                                                                                                                                                                                                                                                                      | Documentation associée                                                                                         |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
+| `intlayer` | Plugin Elysia qui intègre Intlayer dans votre application Elysia. Gère la détection de la locale depuis le storage (cookies, headers) puis depuis `Accept-Language`, injecte un objet `intlayer` exposant `locale`, `t`, `getIntlayer` et `getDictionary` dans le contexte de route, et met en place le contexte de requête `AsyncLocalStorage`. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/elysia-intlayer/intlayer.md) |
+
+### Fonctions
+
+Importer :
+
+```ts
+import { t, getIntlayer, getDictionary } from "elysia-intlayer";
+```
+
+| Fonction        | Description                                                                                                                                                                                                                                                                                           | Documentation associée                                                                                 |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Fonction de traduction globale qui récupère le contenu pour la locale courante dans Elysia. Utilise `AsyncLocalStorage` pour accéder au contexte de requête mis en place par le plugin `intlayer`, et se rabat sur la locale par défaut en dehors de celui-ci. Accessible également via `intlayer.t`. | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/translation.md) |
+| `getIntlayer`   | Récupère un dictionnaire par sa clé depuis la déclaration générée et renvoie son contenu pour la locale courante. Version optimisée de `getDictionary`. Utilise `AsyncLocalStorage` pour accéder au contexte de requête. Accessible également via `intlayer.getIntlayer`.                             | -                                                                                                      |
+| `getDictionary` | Traite les objets dictionnaire et renvoie le contenu pour la locale courante. Traite les traductions `t()`, les énumérations, le markdown, le HTML, etc. Utilise `AsyncLocalStorage` pour accéder au contexte de requête. Accessible également via `intlayer.getDictionary`.                          | -                                                                                                      |
+
+### Types
+
+Importer :
+
+```ts
+import type { IntlayerContext, TranslateFunction } from "elysia-intlayer";
+```
+
+| Type                | Description                                                                                                                                                              |
+| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `IntlayerContext`   | Forme de l'objet `intlayer` injecté dans chaque contexte de route : `locale`, `locale_storage`, `locale_detected`, `defaultLocale`, `t`, `getIntlayer`, `getDictionary`. |
+| `TranslateFunction` | Signature de la fonction de traduction, qui transforme une locale map en contenu correspondant à la locale de la requête courante.                                       |
+
+## Utilisation
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { getDictionary, getIntlayer, intlayer, t } from "elysia-intlayer";
+import dictionaryExample from "./index.content";
+
+const app = new Elysia()
+  // Charger le plugin d'internationalisation
+  .use(intlayer())
+  // Lire la locale et les helpers depuis le contexte de la route
+  .get("/", ({ intlayer }) => ({
+    locale: intlayer!.locale,
+    greeting: intlayer!.t({
+      en: "Hello",
+      fr: "Bonjour",
+      es: "Hola",
+    }),
+    content: intlayer!.getIntlayer("index").exampleOfContent,
+  }))
+  // Ou utiliser les helpers standalone, liés à la requête courante
+  .get("/t_example", () =>
+    t({
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      es: "Ejemplo de contenido devuelto en español",
+    })
+  )
+  .get("/getIntlayer_example", () => getIntlayer("index").exampleOfContent)
+  .get(
+    "/getDictionary_example",
+    () => getDictionary(dictionaryExample).exampleOfContent
+  )
+  .listen(3000);
+
+console.log(
+  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
+);
+```
+
+> Le plugin enregistre son contexte via un `derive` **global**, que Elysia type comme `Partial<{ intlayer: IntlayerContext }>`. La valeur est toujours présente à l'exécution pour les routes enregistrées après `.use(intlayer())`, utilisez donc l'assertion non-nulle (`intlayer!.locale`) — ou l'optional chaining — pour satisfaire TypeScript en mode `strict`.
+
+## Documentation associée
+
+- [Elysia i18n - Guide complet pour traduire votre application](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_with_elysia.md)
+- [Configuration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/configuration.md)

package/docs/fr/packages/elysia-intlayer/intlayer.md

@@ -0,0 +1,137 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Documentation du plugin intlayer pour Elysia | elysia-intlayer
+description: Découvrez comment utiliser le plugin intlayer pour le package elysia-intlayer
+keywords:
+  - intlayer
+  - elysia
+  - plugin
+  - Intlayer
+  - Internationalisation
+  - Documentation
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - intlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Initialisation de la documentation"
+author: aymericzip
+---
+
+# Documentation du plugin intlayer pour Elysia
+
+Le plugin `intlayer` pour Elysia détecte la locale de l'utilisateur et injecte un objet `intlayer` dans le contexte de route. Il permet également l'utilisation des fonctions globales de traduction dans le contexte de la requête.
+
+## Utilisation
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", ({ intlayer }) =>
+  intlayer!.t({
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+> Le plugin enregistre son contexte via un `derive` **global**, que Elysia type comme `Partial<{ intlayer: IntlayerContext }>`. La valeur est toujours présente à l'exécution pour les routes enregistrées après `.use(intlayer())`, utilisez donc l'assertion non-nulle (`intlayer!.t`) — ou l'optional chaining — pour satisfaire TypeScript en mode `strict`.
+
+Les mêmes helpers sont disponibles en tant qu'exports autonomes, afin de pouvoir les appeler sans déstructurer le contexte de route :
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer, t } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", () =>
+  t({
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+## Description
+
+Le plugin effectue les opérations suivantes :
+
+1. **Détection de la locale** : Il lit la locale explicitement définie par le client depuis le storage (cookie, header), puis se rabat sur la locale négociée à partir du header `Accept-Language`.
+2. **Injection dans le contexte** : Il ajoute une propriété `intlayer` au contexte de route Elysia (voir le tableau Contexte de la route ci-dessous).
+3. **Gestion du contexte** : Il utilise `AsyncLocalStorage` pour gérer un contexte asynchrone, permettant aux fonctions globales d'Intlayer (`t`, `getIntlayer`, `getDictionary`) d'accéder à la locale spécifique à la requête sans avoir à transmettre l'objet de contexte.
+4. **Préparation des dictionnaires** : Il appelle `prepareIntlayer` à la création du plugin, afin que les dictionnaires soient construits au démarrage de l'application.
+
+### Contexte de la route
+
+| Propriété         | Type                   | Description                                                                                        |
+| ----------------- | ---------------------- | -------------------------------------------------------------------------------------------------- |
+| `locale`          | `Locale`               | La locale à utiliser pour cette requête, `locale_storage` étant prioritaire sur `locale_detected`. |
+| `locale_storage`  | `Locale` (optionnel)   | La locale explicitement demandée par le client via un cookie ou un header.                         |
+| `locale_detected` | `Locale`               | La locale négociée à partir des headers de la requête.                                             |
+| `defaultLocale`   | `Locale`               | La locale configurée comme fallback dans `intlayer.config.ts`.                                     |
+| `t`               | `TranslateFunction`    | Une fonction de traduction.                                                                        |
+| `getIntlayer`     | `typeof getIntlayer`   | Une fonction pour récupérer les dictionnaires par clé.                                             |
+| `getDictionary`   | `typeof getDictionary` | Une fonction pour traiter les objets dictionnaire.                                                 |
+
+> Contrairement aux plugins Intlayer basés sur Node, `elysia-intlayer` s'appuie sur `AsyncLocalStorage` plutôt que sur `cls-hooked`, car `cls-hooked` dépend de `async_hooks.createHook`, que Bun n'implémente pas.
+
+Le contexte de requête est libéré une fois la réponse mappée, afin que les helpers autonomes ne se résolvent jamais sur une requête déjà terminée. Lorsqu'ils sont appelés en dehors d'une requête gérée par le plugin, ils se rabattent sur la locale par défaut configurée.
+
+## Ordre de résolution de la locale
+
+Par défaut, le plugin résout la locale dans cet ordre :
+
+1. Le cookie `INTLAYER_LOCALE`.
+2. Le header `x-intlayer-locale`.
+3. La négociation du header `Accept-Language`.
+4. La `defaultLocale` configurée.
+
+```bash
+# Négociée depuis `Accept-Language`
+curl -H "Accept-Language: fr" http://localhost:3000/
+# Bonjour
+
+# Le cookie a la priorité sur `Accept-Language`
+curl -H "Accept-Language: fr" -H "Cookie: INTLAYER_LOCALE=es" http://localhost:3000/
+# Hola
+
+# Le header a la priorité sur `Accept-Language`
+curl -H "Accept-Language: fr" -H "x-intlayer-locale: es" http://localhost:3000/
+# Hola
+```
+
+## Configuration
+
+Le plugin lit votre fichier `intlayer.config.ts`. Vous pouvez personnaliser le cookie et le header utilisés pour la détection de la locale :
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  routing: {
+    storage: [
+      { type: "header", name: "my-locale-header" },
+      { type: "cookie", name: "my-locale-cookie" },
+    ],
+  },
+};
+
+export default config;
+```
+
+> Pour plus d'informations sur la configuration, consultez la [documentation de configuration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/configuration.md).
+
+## Documentation associée
+
+- [Documentation du package elysia-intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/elysia-intlayer/exports.md)
+- [Elysia i18n - Guide complet pour traduire votre application](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_with_elysia.md)