@intlayer/docs 9.3.3 → 9.4.0

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

@@ -0,0 +1,134 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Documentación del paquete elysia-intlayer
+description: Plugin de Elysia para Intlayer, que proporciona funciones de traducción y detección de locale.
+keywords:
+  - elysia-intlayer
+  - elysia
+  - plugin
+  - internationalization
+  - i18n
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - exports
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Documentación unificada para todas las exportaciones"
+author: aymericzip
+---
+
+# Paquete elysia-intlayer
+
+El paquete `elysia-intlayer` proporciona un plugin para aplicaciones Elysia para gestionar la internacionalización. Detecta el locale del usuario e inyecta un objeto `intlayer` en el contexto de la ruta.
+
+## Instalación
+
+```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` es una peer dependency (`>=1.0.0`). Elysia está pensado para el runtime **Bun**.
+
+## Exportaciones
+
+### Plugin
+
+Importación:
+
+```ts
+import { intlayer } from "elysia-intlayer";
+```
+
+| Función    | Descripción                                                                                                                                                                                                                                                                                                                                       | Documento relacionado                                                                                          |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `intlayer` | Plugin de Elysia que integra Intlayer en tu aplicación Elysia. Gestiona la detección del locale desde el storage (cookies, headers) y luego desde `Accept-Language`, inyecta un objeto `intlayer` que expone `locale`, `t`, `getIntlayer` y `getDictionary` en el contexto de la ruta, y configura el contexto de request de `AsyncLocalStorage`. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/elysia-intlayer/intlayer.md) |
+
+### Funciones
+
+Importación:
+
+```ts
+import { t, getIntlayer, getDictionary } from "elysia-intlayer";
+```
+
+| Función         | Descripción                                                                                                                                                                                                                                                                     | Documento relacionado                                                                                  |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Función de traducción global que recupera el contenido para el locale actual en Elysia. Usa `AsyncLocalStorage` para acceder al contexto de request configurado por el plugin `intlayer`, y recurre al locale por defecto fuera de él. También accesible mediante `intlayer.t`. | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dictionary/translation.md) |
+| `getIntlayer`   | Recupera un diccionario por su clave desde la declaración generada y devuelve su contenido para el locale actual. Versión optimizada de `getDictionary`. Usa `AsyncLocalStorage` para acceder al contexto de la request. También accesible mediante `intlayer.getIntlayer`.     | -                                                                                                      |
+| `getDictionary` | Procesa objetos de diccionario y devuelve el contenido para el locale actual. Procesa traducciones `t()`, enumeraciones, markdown, HTML, etc. Usa `AsyncLocalStorage` para acceder al contexto de la request. También accesible mediante `intlayer.getDictionary`.              | -                                                                                                      |
+
+### Tipos
+
+Importación:
+
+```ts
+import type { IntlayerContext, TranslateFunction } from "elysia-intlayer";
+```
+
+| Tipo                | Descripción                                                                                                                                                          |
+| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `IntlayerContext`   | Forma del objeto `intlayer` inyectado en cada contexto de ruta: `locale`, `locale_storage`, `locale_detected`, `defaultLocale`, `t`, `getIntlayer`, `getDictionary`. |
+| `TranslateFunction` | Firma de la función de traducción, que convierte un locale map en el contenido correspondiente al locale de la request actual.                                       |
+
+## Uso
+
+```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()
+  // Cargar el plugin de internacionalización
+  .use(intlayer())
+  // Leer la locale y los helpers desde el contexto de la ruta
+  .get("/", ({ intlayer }) => ({
+    locale: intlayer!.locale,
+    greeting: intlayer!.t({
+      en: "Hello",
+      fr: "Bonjour",
+      es: "Hola",
+    }),
+    content: intlayer!.getIntlayer("index").exampleOfContent,
+  }))
+  // O usar los helpers standalone, ligados a la petición actual
+  .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}`
+);
+```
+
+> El plugin registra su contexto mediante un `derive` **global**, que Elysia tipa como `Partial<{ intlayer: IntlayerContext }>`. El valor siempre está presente en tiempo de ejecución para las rutas registradas después de `.use(intlayer())`, así que usa la aserción non-null (`intlayer!.locale`) — u optional chaining — para satisfacer a TypeScript en modo `strict`.
+
+## Documentación relacionada
+
+- [Elysia i18n - Guía completa para traducir tu aplicación](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/intlayer_with_elysia.md)
+- [Configuración](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/configuration.md)

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

@@ -0,0 +1,137 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Documentación del Plugin intlayer para Elysia | elysia-intlayer
+description: Descubre cómo usar el plugin intlayer del paquete elysia-intlayer
+keywords:
+  - intlayer
+  - elysia
+  - plugin
+  - Intlayer
+  - Internacionalización
+  - Documentación
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - intlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Inicialización de la documentación"
+author: aymericzip
+---
+
+# Documentación del Plugin intlayer para Elysia
+
+El plugin `intlayer` para Elysia detecta el locale del usuario e inyecta un objeto `intlayer` en el contexto de la ruta. También permite el uso de funciones globales de traducción dentro del contexto de la request.
+
+## Uso
+
+```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",
+  })
+);
+```
+
+> El plugin registra su contexto mediante un `derive` **global**, que Elysia tipa como `Partial<{ intlayer: IntlayerContext }>`. El valor siempre está presente en tiempo de ejecución para las rutas registradas después de `.use(intlayer())`, así que usa la aserción non-null (`intlayer!.t`) — u optional chaining — para satisfacer a TypeScript en modo `strict`.
+
+Los mismos helpers están disponibles como exports independientes, por lo que puedes llamarlos sin desestructurar el contexto de la ruta:
+
+```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",
+  })
+);
+```
+
+## Descripción
+
+El plugin realiza las siguientes tareas:
+
+1. **Detección de locale**: Lee el locale establecido explícitamente por el cliente desde el storage (cookie, header), y luego recurre al locale negociado a partir del header `Accept-Language`.
+2. **Inyección en el contexto**: Añade una propiedad `intlayer` al contexto de ruta de Elysia (ver la tabla Contexto de la ruta más abajo).
+3. **Gestión del contexto**: Usa `AsyncLocalStorage` para gestionar un contexto asíncrono, permitiendo que las funciones globales de Intlayer (`t`, `getIntlayer`, `getDictionary`) accedan al locale específico de la request sin tener que pasar el objeto de contexto.
+4. **Preparación de los diccionarios**: Llama a `prepareIntlayer` cuando se crea el plugin, de modo que los diccionarios se construyen al arrancar la aplicación.
+
+### Contexto de la ruta
+
+| Propiedad         | Tipo                   | Descripción                                                                                   |
+| ----------------- | ---------------------- | --------------------------------------------------------------------------------------------- |
+| `locale`          | `Locale`               | El locale a usar para esta request; `locale_storage` tiene prioridad sobre `locale_detected`. |
+| `locale_storage`  | `Locale` (opcional)    | El locale solicitado explícitamente por el cliente mediante una cookie o un header.           |
+| `locale_detected` | `Locale`               | El locale negociado a partir de los headers de la request.                                    |
+| `defaultLocale`   | `Locale`               | El locale configurado como fallback en `intlayer.config.ts`.                                  |
+| `t`               | `TranslateFunction`    | Una función de traducción.                                                                    |
+| `getIntlayer`     | `typeof getIntlayer`   | Una función para recuperar diccionarios por clave.                                            |
+| `getDictionary`   | `typeof getDictionary` | Una función para procesar objetos de diccionario.                                             |
+
+> A diferencia de los plugins de Intlayer basados en Node, `elysia-intlayer` se apoya en `AsyncLocalStorage` en lugar de `cls-hooked`, porque `cls-hooked` depende de `async_hooks.createHook`, que Bun no implementa.
+
+El contexto de la request se libera una vez que la respuesta se ha mapeado, de modo que los helpers independientes nunca se resuelven contra una request ya finalizada. Cuando se llaman fuera de una request gestionada por el plugin, recurren al locale por defecto configurado.
+
+## Orden de resolución de la locale
+
+Por defecto, el plugin resuelve la locale en este orden:
+
+1. La cookie `INTLAYER_LOCALE`.
+2. El header `x-intlayer-locale`.
+3. La negociación del header `Accept-Language`.
+4. La `defaultLocale` configurada.
+
+```bash
+# Negociada desde `Accept-Language`
+curl -H "Accept-Language: fr" http://localhost:3000/
+# Bonjour
+
+# La cookie tiene prioridad sobre `Accept-Language`
+curl -H "Accept-Language: fr" -H "Cookie: INTLAYER_LOCALE=es" http://localhost:3000/
+# Hola
+
+# El header tiene prioridad sobre `Accept-Language`
+curl -H "Accept-Language: fr" -H "x-intlayer-locale: es" http://localhost:3000/
+# Hola
+```
+
+## Configuración
+
+El plugin lee tu archivo `intlayer.config.ts`. Puedes personalizar la cookie y el header usados para la detección del 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;
+```
+
+> Para más información sobre la configuración, visita la [documentación de configuración](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/configuration.md).
+
+## Documentación relacionada
+
+- [Documentación del paquete elysia-intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/elysia-intlayer/exports.md)
+- [Elysia i18n - Guía completa para traducir tu aplicación](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/intlayer_with_elysia.md)

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

@@ -0,0 +1,155 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: Documentación de la función getDictionary | intlayer
+description: Consulta cómo usar la función getDictionary para el paquete 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: "Initial documentation"
+author: aymericzip
+---
+
+# Documentación: Función `getDictionary` en `intlayer`
+
+## Descripción
+
+La función `getDictionary` interpreta un objeto de diccionario **que tú mismo pasas** y devuelve su contenido resuelto para una locale determinada. Recorre el contenido en una sola pasada y aplica cada plugin intérprete según sea necesario, resolviendo traducciones `t()`, enumeraciones, condiciones, inserciones, anidamiento, markdown, HTML y nodos de archivo.
+
+A diferencia de [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getIntlayer.md), que busca un diccionario por clave en el registro generado, `getDictionary` toma el diccionario en sí. Esto la convierte en la herramienta correcta para contenido construido en tiempo de ejecución, obtenido de una API o CMS, o declarado en línea en una prueba.
+
+**Características principales:**
+
+- Funciona con cualquier objeto que siga la estructura del diccionario (`{ key, content }`)
+- También acepta un grupo de diccionario calificado (colecciones, variantes) junto con un selector
+- Totalmente tipado: el objeto devuelto refleja el `content` que pasaste
+- Acepta plugins intérpretes personalizados
+
+---
+
+## Firma de Función
+
+```typescript
+getDictionary(
+  dictionary: Dictionary | QualifiedDictionaryGroup, // Requerido
+  localeOrSelector?: LocalesValues | DictionarySelector, // Opcional
+  plugins?: Plugins[]                                // Opcional
+): DeepTransformContent<...>
+```
+
+---
+
+## Parámetros
+
+- `dictionary: Dictionary | QualifiedDictionaryGroup`
+  - **Description**: El diccionario (o grupo de diccionario calificado) a interpretar.
+  - **Type**: `Dictionary | QualifiedDictionaryGroup`
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: La locale para interpretar el contenido, o un objeto selector (`{ item }`, `{ variant }`, opcionalmente con `locale`). Ver [dynamic dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md).
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Un array de transformadores de nodos que definen cómo se interpretan los nodos reconocidos. Si se omite, se utiliza el conjunto predeterminado de plugins de intérprete.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Retorna
+
+- **Type**: El contenido interpretado del diccionario.
+- **Description**: El `content` que pasaste, con cada nodo de Intlayer resuelto para la locale solicitada. Para un grupo de colección sin un selector `item`, se devuelve una matriz ordenada de entradas interpretadas; `null` se devuelve cuando el selector no apunta a nada.
+
+---
+
+## Ejemplo de uso
+
+### Uso Básico
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getDictionary, t } from "intlayer";
+
+const content = getDictionary(
+  {
+    key: "my_key",
+    content: {
+      greeting: t({
+        es: "Hola",
+        en: "Hello",
+        fr: "Bonjour",
+      }),
+    },
+  },
+  "fr"
+);
+
+console.log(content.greeting); // "Bonjour"
+```
+
+### Interpretación de contenido obtenido en tiempo de ejecución
+
+```typescript
+import { getDictionary, type Dictionary } from "intlayer";
+
+const remoteDictionary: Dictionary = await fetch("/api/cms/banner").then(
+  (res) => res.json()
+);
+
+const banner = getDictionary(remoteDictionary, "fr");
+```
+
+### Con un selector
+
+```typescript
+import { getDictionary } from "intlayer";
+
+// Un grupo de diccionario calificado se resuelve en una única entrada…
+const secondItem = getDictionary(blogPostGroup, { item: 2, locale: "fr" });
+
+// …o en un array ordenado cuando no se proporciona `item`
+const allItems = getDictionary(blogPostGroup, { locale: "fr" });
+```
+
+---
+
+## Funciones Relacionadas
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getIntlayer.md): Misma interpretación, pero el diccionario se busca por clave en el registro generado.
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getDictionaryAsync.md): Contraparte para mapas de cargadores por locale.
+- [`useDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/react-intlayer/useDictionary.md): El equivalente del hook de React, leyendo el locale del proveedor.
+
+---
+
+## 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/es/packages/intlayer/getDictionaryAsync.md

@@ -0,0 +1,166 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: Documentación de la función getDictionaryAsync | intlayer
+description: Ve cómo usar la función getDictionaryAsync para el paquete 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
+---
+
+# Documentación: Función `getDictionaryAsync` en `intlayer`
+
+## Descripción
+
+La función `getDictionaryAsync` carga un **único chunk de locale** de un diccionario y devuelve su contenido interpretado.
+
+Es el contraparte de [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getDictionary.md) para los mapas de loader por locale emitidos en `.intlayer/dynamic_dictionaries/`: en lugar de recibir un diccionario que contiene todos los locales, recibe el mapa de loader y espera solo el chunk que el locale solicitado necesita.
+
+> En el código de aplicación normalmente llamas [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getIntlayerAsync.md), no esta función. Los [plugins de build](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/bundle_optimization.md) reescriben cada llamada `getIntlayerAsync('key', locale)` en una `getDictionaryAsync(loaderMap, 'key', locale)`. `getDictionaryAsync` se exporta para loaders personalizados y para herramientas que construyen sus propios mapas de loader.
+
+**Características Principales:**
+
+- Carga solo el chunk de locale que se solicita
+- Soporta mapas de loader simples (`locale → loader`) y calificados (`locale → qualifierId → loader`)
+- Deduplica cargas concurrentes del mismo chunk y cachea el contenido resuelto
+- Las cargas fallidas se evictan del caché para que una llamada posterior reintente el chunk
+
+---
+
+## Firma de la función
+
+```typescript
+getDictionaryAsync(
+  dictionaryLoaders: PlainDynamicLoaderMap | QualifiedDynamicLoaderMap, // Requerido
+  key: string,                                           // Requerido
+  localeOrSelector?: LocalesValues | DictionarySelector, // Opcional
+  plugins?: Plugins[]                                    // Opcional
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## Parámetros
+
+- `dictionaryLoaders: PlainDynamicLoaderMap | QualifiedDynamicLoaderMap`
+  - **Description**: El mapa de cargadores por locale. Los mapas simples asocian un locale con un cargador; los mapas calificados (utilizados por colecciones y variantes) asocian un locale con un id de calificador, luego con un cargador. Para un mapa calificado, solo se cargan los chunk(s) que el selector apunta.
+  - **Type**: `PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap`
+  - **Required**: Yes
+
+- `key: string`
+  - **Description**: La clave del diccionario, utilizada para namespace del caché de chunks.
+  - **Type**: `string`
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: El locale para interpretar el contenido, o un objeto selector (`{ item }`, `{ variant }`, opcionalmente con `locale`). Ver [diccionarios dinámicos](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md).
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Transformadores de nodos. Por defecto el conjunto base del intérprete.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Retorna
+
+- **Type**: `Promise<Content>` — una promesa que se resuelve al contenido interpretado del chunk cargado.
+- **Description**: Se resuelve a `null` cuando el mapa no emite ningún chunk para la locale solicitada ni para ninguno de sus fallbacks, reflejando cómo se resuelve una coordenada calificada faltante.
+
+---
+
+## Ejemplo de Uso
+
+### Con un mapa de cargador generado
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getDictionaryAsync } from "intlayer";
+import appLoaderMap from "../.intlayer/dynamic_dictionaries/app";
+
+const { title } = await getDictionaryAsync(appLoaderMap, "app", "fr");
+```
+
+### Con un mapa de cargadores personalizado
+
+```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");
+```
+
+### Con un selector en un mapa calificado
+
+```typescript
+import { getDictionaryAsync } from "intlayer";
+
+const promoBanner = await getDictionaryAsync(bannerLoaderMap, "banner", {
+  variant: "black-friday",
+  locale: "fr",
+});
+```
+
+---
+
+## Notas de comportamiento
+
+### Almacenamiento en caché y deduplicación
+
+El caché almacena la **promise** de cada triple `key + locale + selector`, por lo que las llamadas concurrentes para el mismo chunk esperan una única carga. Una carga rechazada se elimina del caché, por lo que un chunk que falla se reintenta en la siguiente llamada en lugar de reproducir el mismo error indefinidamente.
+
+### Fallback de locale
+
+Un mapa de loader simple se recorre a lo largo de la misma cadena de fallback que en modo síncrono: primero la locale solicitada, luego sus fallbacks, y luego `null` si ninguno emitió un chunk.
+
+---
+
+## Funciones Relacionadas
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getIntlayerAsync.md): La función que las aplicaciones llaman; los plugins de compilación la reescriben en `getDictionaryAsync`.
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getDictionary.md): Contraparte síncrona que toma un diccionario completo.
+- [Diccionarios dinámicos](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md): Colecciones y variantes, y los mapas de cargadores que generan.
+
+---
+
+## 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/es/packages/intlayer/getEnumeration.md

@@ -31,6 +31,8 @@ author: aymericzip
 
 La función `getEnumeration` recupera contenido correspondiente a una cantidad específica basada en condiciones predefinidas en un objeto de enumeración. Las condiciones se definen como claves, y su prioridad está determinada por su orden en el objeto.
 
+Para más detalles sobre cómo declarar enumeraciones, consulta la [documentación de Enumeración](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dictionary/enumeration.md).
+
 ## Parámetros
 
 - `enumerationContent: QuantityContent<Content>`