@intlayer/docs 9.3.3 → 9.4.0

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

@@ -0,0 +1,197 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: Documentación de la Función getIntlayer | intlayer
+description: Ve cómo usar la función getIntlayer para el paquete intlayer
+keywords:
+  - getIntlayer
+  - dictionary
+  - content
+  - selector
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Documentación: Función `getIntlayer` en `intlayer`
+
+## Descripción
+
+La función `getIntlayer` selecciona un diccionario por su clave y devuelve su contenido interpretado para una locale determinada. Es el equivalente agnóstico del framework del hook `useIntlayer`: mismo contenido, mismos selectores, pero utilizable en cualquier lugar donde un contexto de React no esté disponible — scripts de Node, funciones de servidor, cargadores de rutas, constructores de metadatos, manejadores de Express/Fastify, pruebas.
+
+Lee los diccionarios generados por Intlayer en `.intlayer/`, por lo que el argumento `key` está tipado y autocompletado a partir de tus propias declaraciones de contenido, y el objeto devuelto está completamente tipado hasta cada hoja.
+
+**Características principales:**
+
+- Claves de diccionario tipadas y contenido devuelto tipado
+- Interpreta cada nodo de contenido (`t()`, `enu()`, `cond()`, `insert()`, `nest()`, `md()`, `html()`, `file()`, `gender()`)
+- Acepta una locale u un objeto selector (colecciones, variantes)
+- Los resultados se memorizan por `key + locale + selector`
+- Se retrocede a un proxy seguro en desarrollo cuando falta un diccionario, en lugar de fallar
+
+---
+
+## Firma de función
+
+```typescript
+getIntlayer(
+  key: DictionaryKeys,                        // Requerido
+  localeOrSelector?: LocalesValues | DictionarySelector, // Opcional
+  plugins?: Plugins[]                         // Opcional
+): DeepTransformContent<...>
+```
+
+---
+
+## Parámetros
+
+- `key: DictionaryKeys`
+  - **Description**: The key of the dictionary to read, as declared in your content files.
+  - **Type**: `DictionaryKeys` — a union of every declared dictionary key.
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: The locale to interpret the content with, or a selector object for [dynamic dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md).
+    - `'fr'` — a locale
+    - `{ item: 2 }` — a [collection](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/collections.md) item (omit `item` to get every item as an array)
+    - `{ variant: 'black-friday' }` — a named [variant](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/variants.md) (omit for the `default` one)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — a structured variant
+    - Any selector can carry a locale: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Custom node transformers replacing the base interpreter plugins. Advanced use only; omit it to keep the default behaviour.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Retorna
+
+- **Type**: El contenido interpretado del diccionario, tipado desde tu declaración.
+- **Description**: Un objeto plano que refleja el campo `content` de tu diccionario, donde cada nodo de Intlayer ha sido resuelto a su valor final para la locale solicitada.
+
+---
+
+## Ejemplo de uso
+
+### Uso Básico
+
+```typescript fileName="src/app.content.ts" codeFormat="typescript"
+import { t, type Dictionary } from "intlayer";
+
+const appContent = {
+  key: "app",
+  content: {
+    title: t({
+      es: "Hola",
+      en: "Hello",
+      fr: "Bonjour",
+    }),
+  },
+} satisfies Dictionary;
+
+export default appContent;
+```
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app", "es"); // "Hola"
+```
+
+### Sin locale
+
+Omitir el locale interpreta el contenido con el `defaultLocale` declarado en tu [configuración](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/configuration.md).
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app"); // Interpretado con el locale por defecto
+```
+
+### Dentro de un manejador del servidor
+
+```typescript fileName="src/routes/greeting.ts" codeFormat="typescript"
+import { getIntlayer, getLocale } from "intlayer";
+
+export const greetingHandler = async (request: Request) => {
+  const locale = await getLocale({
+    getHeader: (name) => request.headers.get(name) ?? undefined,
+  });
+
+  const { title } = getIntlayer("app", locale);
+
+  return Response.json({ title });
+};
+```
+
+### Con un selector (colecciones y variantes)
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+// Un elemento único de la colección
+const secondPost = getIntlayer("blog-post", { item: 2, locale: "fr" });
+
+// Todos los elementos de la colección, como un array ordenado
+const allPosts = getIntlayer("blog-post", { locale: "fr" });
+
+// Una variante nombrada
+const banner = getIntlayer("banner", { variant: "black-friday", locale: "fr" });
+```
+
+---
+
+## Notas de Comportamiento
+
+### Caché
+
+Los resultados se memorizan en un caché a nivel de módulo, con clave `key + locale + selector`. Llamar a `getIntlayer("app", "fr")` repetidamente interpreta el diccionario una sola vez y devuelve el mismo objeto después.
+
+### Diccionarios faltantes
+
+En desarrollo, solicitar una clave que no tiene un diccionario generado registra una advertencia una vez y devuelve un proxy de respaldo seguro: leer `content.title` produce la cadena `"app.title"` en lugar de lanzar una excepción. Esto mantiene una página utilizable mientras se corrige la declaración faltante. Ejecuta la compilación de Intlayer (o el servidor de desarrollo) para que se genere el diccionario.
+
+### Tamaño del bundle
+
+`getIntlayer` lee el diccionario fusionado, que contiene **todos** los locales. En bundles del cliente, los [plugins de compilación](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/bundle_optimization.md) reescriben la llamada para que solo se envíe el contenido requerido. Cuando lees contenido fuera de la renderización (metadatos, loaders, funciones de servidor) y deseas que un único local se cargue bajo demanda, utiliza [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getIntlayerAsync.md) en su lugar.
+
+---
+
+## Funciones Relacionadas
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getIntlayerAsync.md): Contraparte asincrónica que carga un único chunk de locale.
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getDictionary.md): Interpreta un objeto de diccionario que pasas tú mismo, en lugar de uno buscado por clave.
+- [`useIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/react-intlayer/useIntlayer.md): El equivalente del hook de React, leyendo el locale del provider.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayer<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): DeepTransformContent<
+  DictionaryRegistryResult<T, A>,
+  IInterpreterPluginState,
+  ExtractSelectorLocale<A>
+>;
+```

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

@@ -0,0 +1,141 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: Documentación de la función getIntlayerAsync | intlayer
+description: Consulta cómo utilizar la función getIntlayerAsync del paquete intlayer
+keywords:
+  - getIntlayerAsync
+  - dictionary
+  - dynamic import
+  - metadata
+  - bundle optimization
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayerAsync
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Documentación: Función `getIntlayerAsync` en `intlayer`
+
+## Descripción
+
+La función `getIntlayerAsync` selecciona un diccionario por su clave y resuelve su contenido para una localidad determinada, **cargando solo esa localidad**.
+
+Es la contraparte asincrónica de [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getIntlayer.md), destinada a los lugares donde se lee un diccionario fuera del renderizado — constructores de rutas `head` / metadatos, loaders, funciones de servidor.
+
+Mientras que `getIntlayer` carga el diccionario fusionado que contiene todas las localidades, los [plugins de construcción](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/bundle_optimization.md) (`@intlayer/babel`, `@intlayer/swc`) reescriben esta llamada en `getDictionaryAsync(loaderMap, key, locale)`, apuntando a los fragmentos por localidad en `.intlayer/dynamic_dictionaries/`. El bundle por lo tanto solo carga la localidad realmente solicitada.
+
+Sin esos plugins — una construcción no optimizada — la llamada se resuelve a través del registro de diccionarios sincrónico en su lugar: el mismo contenido, sin la división por localidad.
+
+**Características Clave:**
+
+- Las mismas claves tipadas, selectores y contenido devuelto que `getIntlayer`
+- Carga solo el fragmento de localidad solicitado en construcciones optimizadas
+- Las llamadas concurrentes para el mismo fragmento comparten una única carga
+- Seguro de usar en constructores de metadatos `async`, loaders y funciones de servidor
+
+---
+
+## Firma de Función
+
+```typescript
+getIntlayerAsync(
+  key: DictionaryKeys,                        // Requerido
+  localeOrSelector?: LocalesValues | DictionarySelector, // Opcional
+  plugins?: Plugins[]                         // Opcional
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## Parámetros
+
+- `key: DictionaryKeys`
+  - **Description**: La clave del diccionario a leer, tal como se declara en tus archivos de contenido.
+  - **Type**: `DictionaryKeys` — una unión de cada clave de diccionario declarada.
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: La locale para interpretar el contenido, o un objeto selector para [diccionarios dinámicos](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md).
+    - `'fr'` — una locale
+    - `{ item: 2 }` — un elemento de [colección](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/collections.md) (omite `item` para obtener cada elemento como un array)
+    - `{ variant: 'black-friday' }` — una [variante](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/variants.md) nombrada (omite para la `default`)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — una variante estructurada
+    - Cualquier selector puede llevar una locale: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — por defecto la `defaultLocale` configurada.
+
+- `plugins: Plugins[]`
+  - **Description**: Transformadores de nodos personalizados que reemplazan los plugins base del intérprete. Solo uso avanzado.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Devoluciones
+
+- **Type**: `Promise<Content>` — una promesa que se resuelve al contenido interpretado del diccionario, tipado desde tu declaración.
+
+---
+
+## Ejemplo de uso
+
+### Uso Básico
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayerAsync } from "intlayer";
+
+const { title } = await getIntlayerAsync("app", "fr"); // "Bonjour"
+```
+
+---
+
+## `getIntlayer` vs `getIntlayerAsync`
+
+|                     | [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getIntlayer.md) | `getIntlayerAsync`                                 |
+| ------------------- | --------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
+| Devuelve            | El contenido                                                                                                    | Una promesa del contenido                          |
+| Diccionario cargado | El diccionario fusionado (todas las locales)                                                                    | El chunk de la locale solicitada únicamente        |
+| Mejor para          | Renderizado, rutas de código sincrónicas                                                                        | Metadatos, loaders, funciones del servidor         |
+| ¿Requiere plugin?   | No                                                                                                              | No — la división por locale requiere plugins build |
+
+Ambos aceptan los mismos argumentos y devuelven el mismo contenido: cambiar de uno a otro solo cambia **cuándo** y **cuánto** se carga.
+
+---
+
+## Funciones Relacionadas
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getIntlayer.md): Equivalente síncrono que lee el diccionario combinado.
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getDictionaryAsync.md): La función de nivel inferior que los plugins de compilación reescriben en esta llamada.
+- [`getLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getLocale.md): Detecta el locale de una solicitud entrante.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayerAsync<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): Promise<
+  DeepTransformContent<
+    DictionaryRegistryResult<T, A>,
+    IInterpreterPluginState,
+    ExtractSelectorLocale<A>
+  >
+>;
+```

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

@@ -31,6 +31,8 @@ author: aymericzip
 
 La función `getLocalizedPath` resuelve una ruta canónica (ruta interna de la aplicación) en su equivalente localizado según el locale proporcionado y las reglas de reescritura. Es especialmente útil para generar URLs optimizadas para SEO que varían según el idioma.
 
+Es el equivalente relativo de [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getLocalizedUrl.md) — para una entrada relativa ambos devuelven el mismo valor. A diferencia de `getLocalizedUrl`, nunca devuelve una URL absoluta: la configuración de `domains` se ignora, por lo que una locale servida desde su propio dominio sigue produciendo una ruta. Se acepta una entrada absoluta, pero su origen se descarta — solo se conservan su ruta, query string y hash.
+
 **Características clave:**
 
 - Soporta parámetros de ruta dinámicos usando la sintaxis `[param]`.
@@ -60,18 +62,23 @@ getLocalizedPath(
   - **Tipo**: `string`
   - **Obligatorio**: Sí
 
-- `locale: Locales`
-  - **Descripción**: La locale objetivo para la que se debe localizar la ruta.
-  - **Tipo**: `Locales`
-  - **Obligatorio**: Sí
-
 ### Parámetros opcionales
 
+- `locale?: Locales`
+  - **Description**: La locale objetivo para la cual la ruta debe localizarse.
+  - **Type**: `Locales`
+  - **Default**: La locale predeterminada de la configuración de tu proyecto.
+
 - `rewriteRules?: RoutingConfig['rewrite']`
   - **Descripción**: Un objeto que define reglas de reescritura personalizadas. Si no se proporciona, por defecto usa la propiedad `routing.rewrite` de la configuración de tu proyecto.
   - **Tipo**: `RoutingConfig['rewrite']`
   - **Predeterminado**: `configuration.routing.rewrite`
 
+  - `options.locales?: Locales[]` — locales soportados. **Default**: `configuration.internationalization.locales`
+  - `options.defaultLocale?: Locales` — la locale por defecto. **Default**: `configuration.internationalization.defaultLocale`
+  - `options.mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params'` — cómo aparece la locale en la ruta. **Default**: `configuration.routing.mode`
+  - `options.rewrite?: RoutingConfig['rewrite']` — reglas de reescritura personalizadas. **Default**: `configuration.routing.rewrite`
+
 ---
 
 ## Devuelve
@@ -79,6 +86,28 @@ getLocalizedPath(
 - **Tipo**: `string`
 - **Descripción**: La ruta localizada para la locale especificada.
 
+El tipo se reduce a partir de las reglas de reescritura declaradas en tu configuración, por lo que el editor muestra la ruta resuelta en lugar de un simple `string`:
+
+```typescript codeFormat="typescript"
+// Configuración: modo 'prefix-no-default', defaultLocale 'en',
+//                { '/about': { fr: '/a-propos' }, '/product/[id]': { fr: '/produit/[id]' } }
+const about = getLocalizedPath("/about", Locales.FRENCH);
+//    ^? '/fr/a-propos'
+const product = getLocalizedPath("/product/123", Locales.FRENCH);
+//    ^? '/fr/produit/123'
+const contact = getLocalizedPath("/contact", Locales.FRENCH);
+//    ^? '/fr/contact'  (ninguna regla de reescritura coincide, solo se aplica el prefijo)
+const home = getLocalizedPath("/", Locales.FRENCH);
+//    ^? '/fr'
+```
+
+El mismo estrechamiento fluye hacia [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/intlayer/getLocalizedUrl.md), que aplica las reglas de reescritura antes de añadir el prefijo de la configuración regional.
+
+Dos casos se mantienen ampliados a `string`, porque no pueden resolverse en tiempo de compilación:
+
+- una ruta que no es un literal de string (por ejemplo, una construida a partir de una variable);
+- una ruta coincidente con una regla que utiliza un parámetro de múltiples segmentos u opcional (`[...slug]`, `[[...slug]]`, `:param?`).
+
 ---
 
 ## Ejemplo de uso
@@ -126,6 +155,18 @@ getLocalizedPath("/contact", Locales.FRENCH, manualRules);
 // Salida: "/contactez-nous"
 ```
 
+### Omitiendo la Configuración Regional
+
+Cuando no se proporciona una configuración regional, la ruta se localiza para la configuración regional predeterminada configurada:
+
+```typescript codeFormat="typescript"
+import { getLocalizedPath } from "intlayer";
+
+// Configuración: defaultLocale = Locales.ENGLISH, { '/about': { en: '/about', fr: '/a-propos' } }
+getLocalizedPath("/about");
+// Salida: "/about"
+```
+
 ---
 
 ## Funciones relacionadas

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

@@ -143,36 +143,6 @@ getLocalizedUrl(
 // Salida: "/about" para el locale por defecto (inglés)
 ```
 
-```javascript codeFormat="esm"
-import { getLocalizedUrl, Locales } from "intlayer";
-
-getLocalizedUrl(
-  "/about",
-  Locales.FRENCH,
-  [Locales.ENGLISH, Locales.FRENCH],
-  Locales.ENGLISH,
-  false
-);
-
-// Salida: "/fr/about" para el locale francés
-// Salida: "/about" para el locale por defecto (inglés)
-```
-
-```javascript codeFormat="commonjs"
-const { getLocalizedUrl, Locales } = require("intlayer");
-
-getLocalizedUrl(
-  "/about",
-  Locales.FRENCH,
-  [Locales.ENGLISH, Locales.FRENCH],
-  Locales.ENGLISH,
-  false
-);
-
-// Salida: "/fr/about" para el locale francés
-// Salida: "/about" para el locale por defecto (inglés)
-```
-
 ### Anulación Parcial de Configuración
 
 También puede proporcionar solo algunos de los parámetros opcionales. La función utilizará la configuración de su proyecto para los parámetros que no especifique:
@@ -249,6 +219,12 @@ getLocalizedUrl(
 - **Locales No Soportados:**
   - Para locales que no están listados en `locales`, la función no aplica ningún prefijo.
 
+- **Modos de enrutamiento:**
+  - `'prefix-no-default'`: La locale por defecto no tiene prefijo, otras sí (p. ej., `/about`, `/fr/about`)
+  - `'prefix-all'`: Todas las locales tienen prefijos (p. ej., `/en/about`, `/fr/about`)
+  - `'no-prefix'`: Sin prefijos de locale en las URLs (locale manejada en otro lugar)
+  - `'search-params'`: Locale especificada mediante parámetro de consulta (p. ej., `/about?locale=fr`)
+
 ---
 
 ## Uso en Aplicaciones

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

@@ -31,6 +31,14 @@ author: aymericzip
 
 La función `getMultilingualUrls` genera un mapeo de URLs multilingües anteponiendo la URL dada con cada localización soportada. Puede manejar tanto URLs absolutas como relativas, aplicando el prefijo de localización apropiado basado en la configuración proporcionada o los valores predeterminados.
 
+**Características principales:**
+
+- Solo 1 parámetro es requerido: `url`
+- Objeto `options` opcional con `locales`, `defaultLocale`, y `mode`
+- Utiliza la configuración de internacionalización de tu proyecto como valores por defecto
+- Soporta múltiples modos de enrutamiento: `prefix-no-default`, `prefix-all`, `no-prefix`, y `search-params`
+- Devuelve un objeto de mapeo con todas las locales como claves y sus URLs correspondientes como valores
+
 ---
 
 ## Firma de función
@@ -139,8 +147,6 @@ getMultilingualUrls(
 // }
 ```
 
----
-
 ### Diferentes modos de enrutamiento
 
 ```typescript
@@ -206,6 +212,12 @@ getMultilingualUrls("/dashboard", {
 - **Idiomas No Soportados:**
   - Solo se consideran los idiomas proporcionados en el arreglo `locales` para generar las URLs.
 
+- **Modos de enrutamiento:**
+  - `'prefix-no-default'`: La locale predeterminada no tiene prefijo, otras sí (p. ej., `/dashboard`, `/fr/dashboard`)
+  - `'prefix-all'`: Todas las locales tienen prefijos (p. ej., `/en/dashboard`, `/fr/dashboard`)
+  - `'no-prefix'`: Sin prefijos de locale en URLs (todas las locales devuelven la misma URL)
+  - `'search-params'`: Locale especificada mediante parámetro de consulta (p. ej., `/dashboard?locale=fr`)
+
 ---
 
 ## Uso en Aplicaciones

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

@@ -31,6 +31,8 @@ author: aymericzip
 
 La función `getTranslationContent` recupera el contenido correspondiente a una localidad específica de un conjunto de contenido de idioma personalizable. Si no se encuentra la localidad especificada, devuelve por defecto el contenido de la localidad predeterminada configurada en el proyecto.
 
+Para más detalles sobre cómo declarar traducciones, consulta la [documentación de traducción](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dictionary/translation.md).
+
 ## Parámetros
 
 - `languageContent: CustomizableLanguageContent<Content>`

package/docs/es/packages/next-intlayer/t.md

@@ -158,6 +158,23 @@ En `next-intlayer`, la localización actual se gestiona a través de proveedores
 
 #### Ejemplo:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx codeFormat={["typescript", "esm", "commonjs"]}
+import type { FC, ReactNode } from "react";
+import type { Locales } from "intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const Page: FC<{ locale: Locales; children: ReactNode }> = ({
+  locale,
+  children,
+}) => <IntlayerProvider locale={locale}>{children}</IntlayerProvider>;
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx codeFormat={["typescript", "esm", "commonjs"]}
 import type { FC } from "react";
 import type { Locales } from "intlayer";
@@ -173,6 +190,9 @@ const Page: FC<{ locale: Locales }> = ({ locale }) => (
 );
 ```
 
+ </Tab>
+</Tabs>
+
 ---
 
 ## Errores Comunes y Solución de Problemas

package/docs/es/packages/next-intlayer/useIntlayer.md

@@ -79,6 +79,34 @@ Las instrucciones para configurar archivos de declaración de contenido están d
 
 Aquí se muestra cómo puedes implementar el hook `useIntlayer` dentro de una página de Next.js para cargar dinámicamente contenido localizado según la configuración regional actual de la aplicación:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
+import { ClientComponentExample } from "@components/ClientComponentExample";
+import { ServerComponentExample } from "@components/ServerComponentExample";
+import { type NextPageIntlayer } from "next-intlayer";
+import { useIntlayer } from "next-intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const HomePage: NextPageIntlayer = async ({ params }) => {
+  const { locale } = await params;
+
+  const content = useIntlayer("homepage", locale);
+
+  return (
+    <IntlayerProvider locale={locale}>
+      <p>{content.introduction}</p>
+      <ClientComponentExample />
+      <ServerComponentExample />
+    </IntlayerProvider>
+  );
+};
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
 import { ClientComponentExample } from "@components/ClientComponentExample";
 import { ServerComponentExample } from "@components/ServerComponentExample";
@@ -104,6 +132,9 @@ const HomePage: NextPageIntlayer = async ({ params }) => {
 };
 ```
 
+ </Tab>
+</Tabs>
+
 ```tsx fileName="src/components/ClientComponentExample.tsx" codeFormat={["typescript", "esm"]}
 "use-client";
 

package/docs/es/packages/next-intlayer/useLocale.md

@@ -104,6 +104,8 @@ El hook `useLocale` acepta los siguientes parámetros:
 
 ## Valores de Retorno
 
+Cuando invocas el hook `useLocale`, devuelve un objeto que contiene las siguientes propiedades:
+
 - **`locale`**: La configuración regional actual establecida en el contexto de React.
 - **`defaultLocale`**: La configuración regional principal definida en la configuración.
 - **`availableLocales`**: Una lista de todas las configuraciones regionales disponibles según lo definido en la configuración.

package/docs/es/packages/react-intlayer/useDictionary.md

@@ -30,8 +30,6 @@ Esta sección proporciona una guía detallada sobre el uso del hook `useDictiona
 
 ## Ejemplo de uso en React
 
-A continuación se muestra un ejemplo de cómo usar el hook `useDictionary` en un componente React:
-
 ```tsx fileName="./ComponentExample.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
 import { useDictionary } from "react-intlayer";

package/docs/es/packages/react-intlayer/useI18n.md

@@ -77,6 +77,34 @@ Todas las claves del diccionario deben declararse dentro de archivos de declarac
 
 Ejemplos de uso del hook `useI18n` dentro de componentes React:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx fileName="src/App.tsx" codeFormat={["typescript", "esm"]}
+import type { FC } from "react";
+import { ClientComponentExample, ServerComponentExample } from "@components";
+import { IntlayerProvider } from "react-intlayer";
+import { useI18n } from "react-intlayer/server";
+import { Locales } from "intlayer";
+
+const App: FC<{ locale: Locales }> = ({ locale }) => {
+  const t = useI18n("home-page", locale);
+
+  return (
+    <>
+      <p>{t("introduction")}</p>
+      <IntlayerProvider locale={locale}>
+        <ClientComponentExample />
+      </IntlayerProvider>
+      <ServerComponentExample />
+    </>
+  );
+};
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx fileName="src/App.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
 import { ClientComponentExample, ServerComponentExample } from "@components";
@@ -101,6 +129,9 @@ const App: FC<{ locale: Locales }> = ({ locale }) => {
 };
 ```
 
+</Tab>
+</Tabs>
+
 ```tsx fileName="src/components/ComponentExample.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
 import { useI18n } from "react-intlayer";