@intlayer/docs 9.3.3 → 9.4.0

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)

package/docs/fr/packages/intlayer/getDictionary.md

@@ -0,0 +1,154 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: Documentation de la fonction getDictionary | intlayer
+description: Voir comment utiliser la fonction getDictionary pour le package intlayer
+keywords:
+  - getDictionary
+  - dictionary
+  - interpreter
+  - content
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getDictionary
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Documentation initiale"
+author: aymericzip
+---
+
+# Documentation : fonction `getDictionary` dans `intlayer`
+
+## Description
+
+La fonction `getDictionary` interprète un objet dictionnaire **que vous passez vous-même** et retourne son contenu résolu pour une locale donnée. Elle parcourt le contenu en une seule passe et applique chaque plugin interpréteur selon les besoins, en résolvant les traductions `t()`, les énumérations, les conditions, les insertions, l'imbrication, le markdown, le HTML et les nœuds de fichier.
+
+Contrairement à [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getIntlayer.md), qui recherche un dictionnaire par clé dans le registre généré, `getDictionary` prend le dictionnaire lui-même. Cela en fait l'outil idéal pour le contenu construit à l'exécution, récupéré à partir d'une API ou d'un CMS, ou déclaré en ligne dans un test.
+
+**Fonctionnalités clés :**
+
+- Fonctionne avec n'importe quel objet suivant la structure du dictionnaire (`{ key, content }`)
+- Accepte également un groupe de dictionnaire qualifié (collections, variantes) avec un sélecteur
+- Entièrement typé : l'objet retourné reflète le `content` que vous avez passé
+- Accepte les plugins interpréteurs personnalisés
+
+---
+
+## Signature de fonction
+
+```typescript
+getDictionary(
+  dictionary: Dictionary | QualifiedDictionaryGroup, // Requis
+  localeOrSelector?: LocalesValues | DictionarySelector, // Optionnel
+  plugins?: Plugins[]                                // Optionnel
+): DeepTransformContent<...>
+```
+
+---
+
+## Paramètres
+
+- `dictionary: Dictionary | QualifiedDictionaryGroup`
+  - **Description**: Le dictionnaire (ou groupe de dictionnaire qualifié) à interpréter.
+  - **Type**: `Dictionary | QualifiedDictionaryGroup`
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: La locale pour interpréter le contenu avec, ou un objet sélecteur (`{ item }`, `{ variant }`, optionnellement avec `locale`). Voir [dictionnaires dynamiques](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/index.md).
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Un tableau de transformateurs de nœuds définissant comment les nœuds reconnus sont interprétés. Si omis, l'ensemble par défaut des plugins d'interprétation est utilisé.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Retours
+
+- **Type** : Le contenu interprété du dictionnaire.
+- **Description** : Le `content` que vous avez transmis, avec chaque nœud Intlayer résolu pour la locale demandée. Pour un groupe de collection sans sélecteur `item`, un tableau ordonné d'entrées interprétées est retourné ; `null` est retourné lorsque le sélecteur ne cible rien.
+
+---
+
+## Exemple d'utilisation
+
+### Utilisation de base
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getDictionary, t } from "intlayer";
+
+const content = getDictionary(
+  {
+    key: "my_key",
+    content: {
+      greeting: t({
+        fr: "Bonjour",
+        en: "Hello",
+      }),
+    },
+  },
+  "fr"
+);
+
+console.log(content.greeting); // "Bonjour"
+```
+
+### Interprétation du contenu récupéré à l'exécution
+
+```typescript
+import { getDictionary, type Dictionary } from "intlayer";
+
+const remoteDictionary: Dictionary = await fetch("/api/cms/banner").then(
+  (res) => res.json()
+);
+
+const banner = getDictionary(remoteDictionary, "fr");
+```
+
+### Avec un sélecteur
+
+```typescript
+import { getDictionary } from "intlayer";
+
+// Un groupe de dictionnaire qualifié est résolu en une seule entrée…
+const secondItem = getDictionary(blogPostGroup, { item: 2, locale: "fr" });
+
+// …ou en un tableau ordonné quand aucun `item` n'est fourni
+const allItems = getDictionary(blogPostGroup, { locale: "fr" });
+```
+
+---
+
+## Fonctions Associées
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getIntlayer.md): Même interprétation, mais le dictionnaire est recherché par clé dans le registre généré.
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getDictionaryAsync.md): Équivalent pour les cartes de chargeurs par locale.
+- [`useDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/useDictionary.md): L'équivalent du hook React, lisant la locale depuis le fournisseur.
+
+---
+
+## TypeScript
+
+```typescript
+function getDictionary<
+  const T extends Dictionary | QualifiedDictionaryGroup,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  dictionary: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): DeepTransformContent<
+  ResolveQualifiedDictionaryContent<T, A>,
+  IInterpreterPluginState,
+  ExtractSelectorLocale<A>
+>;
+```

package/docs/fr/packages/intlayer/getDictionaryAsync.md

@@ -0,0 +1,166 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: Documentation de la fonction getDictionaryAsync | intlayer
+description: Découvrez comment utiliser la fonction getDictionaryAsync du package intlayer
+keywords:
+  - getDictionaryAsync
+  - dictionary
+  - dynamic dictionaries
+  - loader map
+  - bundle optimization
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getDictionaryAsync
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Documentation : fonction `getDictionaryAsync` dans `intlayer`
+
+## Description
+
+La fonction `getDictionaryAsync` charge un **chunk de locale unique** d'un dictionnaire et retourne son contenu interprété.
+
+C'est l'équivalent de [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getDictionary.md) pour les maps de loaders par locale émis dans `.intlayer/dynamic_dictionaries/` : au lieu de recevoir un dictionnaire contenant chaque locale, elle reçoit la map de loader et attend uniquement le chunk dont la locale demandée a besoin.
+
+> Dans le code de l'application, vous appelez normalement [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getIntlayerAsync.md), et non cette fonction. Les [plugins de build](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/bundle_optimization.md) réécrivent chaque appel `getIntlayerAsync('key', locale)` en `getDictionaryAsync(loaderMap, 'key', locale)`. `getDictionaryAsync` est exportée pour les loaders personnalisés et pour les outils qui construisent leurs propres maps de loader.
+
+**Fonctionnalités clés :**
+
+- Charge uniquement le chunk de locale qui est demandé
+- Supporte les maps de loaders simples (`locale → loader`) et qualifiées (`locale → qualifierId → loader`)
+- Déduplique les chargements concurrents du même chunk et met en cache le contenu résolu
+- Les chargements échoués sont évincés du cache afin qu'un appel ultérieur relance le chunk
+
+---
+
+## Signature de fonction
+
+```typescript
+getDictionaryAsync(
+  dictionaryLoaders: PlainDynamicLoaderMap | QualifiedDynamicLoaderMap, // Requis
+  key: string,                                           // Requis
+  localeOrSelector?: LocalesValues | DictionarySelector, // Optionnel
+  plugins?: Plugins[]                                    // Optionnel
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## Paramètres
+
+- `dictionaryLoaders: PlainDynamicLoaderMap | QualifiedDynamicLoaderMap`
+  - **Description**: La carte des loaders par locale. Les cartes simples associent une locale à un loader ; les cartes qualifiées (utilisées par les collections et les variantes) associent une locale à un id de qualifiant, puis à un loader. Pour une carte qualifiée, seul le ou les chunk(s) ciblé(s) par le sélecteur sont chargés.
+  - **Type**: `PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap`
+  - **Required**: Yes
+
+- `key: string`
+  - **Description**: La clé du dictionnaire, utilisée pour namespacecer le cache des chunks.
+  - **Type**: `string`
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: La locale pour interpréter le contenu, ou un objet sélecteur (`{ item }`, `{ variant }`, optionnellement avec `locale`). Voir [dictionnaires dynamiques](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/index.md).
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Node transformers. Defaults to the base interpreter set.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Retourne
+
+- **Type**: `Promise<Content>` — une promesse qui se résout au contenu interprété du chunk chargé.
+- **Description**: Se résout à `null` lorsque la map n'émet aucun chunk pour la locale demandée ni pour l'une de ses alternatives, reflétant la façon dont une coordonnée qualifiée manquante se résout.
+
+---
+
+## Exemple d'utilisation
+
+### Avec une carte de chargement générée
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getDictionaryAsync } from "intlayer";
+import appLoaderMap from "../.intlayer/dynamic_dictionaries/app";
+
+const { title } = await getDictionaryAsync(appLoaderMap, "app", "fr");
+```
+
+### Avec une carte de chargeur personnalisée
+
+```typescript
+import { getDictionaryAsync } from "intlayer";
+
+const loaderMap = {
+  en: () => import("./banner.en.json").then((mod) => mod.default),
+  fr: () => import("./banner.fr.json").then((mod) => mod.default),
+};
+
+const banner = await getDictionaryAsync(loaderMap, "banner", "fr");
+```
+
+### Avec un sélecteur sur une map qualifiée
+
+```typescript
+import { getDictionaryAsync } from "intlayer";
+
+const promoBanner = await getDictionaryAsync(bannerLoaderMap, "banner", {
+  variant: "black-friday",
+  locale: "fr",
+});
+```
+
+---
+
+## Notes sur le comportement
+
+### Mise en cache et déduplication
+
+Le cache stocke la **promise** de chaque triplet `key + locale + selector`, de sorte que les appels concurrents pour le même chunk attendent un seul chargement. Un chargement rejeté est supprimé du cache, donc un chunk défaillant est réessayé lors de l'appel suivant au lieu de rejouer le même échec indéfiniment.
+
+### Fallback de locale
+
+Une carte de chargeur simple est parcourue selon la même chaîne de fallback que le mode synchrone : d'abord la locale demandée, puis ses fallbacks, puis `null` si aucun n'a émis un chunk.
+
+---
+
+## Fonctions associées
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getIntlayerAsync.md): La fonction que les applications appellent ; les plugins de build la réécrivent en `getDictionaryAsync`.
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getDictionary.md): Équivalent synchrone prenant un dictionnaire complet.
+- [Dictionnaires dynamiques](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/index.md): Collections et variantes, et les cartes de loader qu'elles génèrent.
+
+---
+
+## TypeScript
+
+```typescript
+function getDictionaryAsync<
+  const T extends Dictionary,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  dictionaryLoaders: PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap,
+  key: string,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): Promise<
+  DeepTransformContent<
+    T["content"],
+    IInterpreterPluginState,
+    ExtractSelectorLocale<A>
+  >
+>;
+```

package/docs/fr/packages/intlayer/getEnumeration.md

@@ -31,6 +31,8 @@ author: aymericzip
 
 La fonction `getEnumeration` récupère le contenu correspondant à une quantité spécifique en fonction de conditions prédéfinies dans un objet d'énumération. Les conditions sont définies comme des clés, et leur priorité est déterminée par leur ordre dans l'objet.
 
+Pour plus de détails sur la façon de déclarer des énumérations, voir la [documentation Enumeration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/enumeration.md).
+
 ## Paramètres
 
 - `enumerationContent: QuantityContent<Content>`