@intlayer/docs 9.1.3 → 9.2.0

package/docs/es/analytics.md

@@ -0,0 +1,222 @@
+---
+createdAt: 2026-07-08
+updatedAt: 2026-07-08
+title: Intlayer Analytics | Seguimiento de la exposición del contenido y pruebas A/B
+description: Descubre cómo @intlayer/analytics rastrea las vistas de páginas/configuraciones regionales y la exposición del contenido, y cómo usarlo para ejecutar pruebas A/B en tu contenido de Intlayer.
+keywords:
+  - Analítica
+  - Pruebas A/B
+  - Audiencia
+  - Internacionalización
+  - Documentación
+  - Intlayer
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - concept
+  - analytics
+history:
+  - version: 9.0.0
+    date: 2026-07-08
+    changes: "Init doc — paquete @intlayer/analytics, seguimiento a nivel de proveedor/nodo, pruebas A/B, panel de control"
+author: aymericzip
+---
+
+# Documentación de Intlayer Analytics
+
+`@intlayer/analytics` es un paquete complementario opcional que te indica **qué contenido se muestra realmente** a tus visitantes — qué página, en qué configuración regional (locale) y qué fragmento específico de contenido traducido — para que puedas entender a tu audiencia y ejecutar **pruebas A/B en el contenido**.
+
+## Tabla de Contenidos
+
+<TOC/>
+
+---
+
+## Qué rastrea
+
+`@intlayer/analytics` agrupa tres tipos de eventos anónimos:
+
+| Evento             | Dónde se captura                           | Qué te indica                                                                                                                 |
+| ------------------ | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
+| `page_view`        | Nivel de proveedor (`IntlayerProvider`)    | Qué página y locale vio una sesión, en la carga inicial, cambio de ruta o cambio de locale.                                   |
+| `content_exposure` | Nivel de nodo (`useIntlayer` / plugins)    | Qué clave de diccionario / ruta de clave se resolvió y mostró realmente — y, si es parte de un experimento, qué **variante**. |
+| `conversion`       | Dondequiera que llames a `useConversion()` | Un objetivo alcanzado (registro, clic, compra...) atribuido a la variante A/B a la que se expuso la sesión.                   |
+
+Los eventos se recopilan en memoria y se envían como una **sola solicitud por lotes aproximadamente cada 20 segundos** — nunca en cada pulsación de tecla o renderizado — por lo que la analítica nunca afecta el tiempo de primer renderizado ni añade una solicitud por cada interacción.
+
+## Cómo impulsa las pruebas A/B en el contenido
+
+Intlayer ya te permite declarar [Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md) de contenido (por ejemplo, un diccionario `hero-banner` con una variante `control` y una `black_friday`). `@intlayer/analytics` cierra el ciclo:
+
+1. `getVariant(experimentKey, variants)` asigna de manera determinista cada sesión anónima a una variante — una función pura del id de sesión y la clave del experimento, por lo que la asignación es **estable durante toda la sesión** y no requiere **ida y vuelta al servidor** antes del primer renderizado (sin parpadeos, sin cambios de diseño).
+2. Cada evento de `content_exposure` lleva la `variant` que se mostró.
+3. `useConversion()` te permite atribuir un objetivo (por ejemplo, `"cta_click"`) a esa variante.
+4. El endpoint de resultados de experimentos del panel de control compara las tasas de conversión por variante, incluyendo la significancia estadística (una prueba z).
+
+## Instalación
+
+`@intlayer/analytics` es una dependencia **par y opcional** — nunca instalada automáticamente por un paquete de framework. Añádela junto a `intlayer`:
+
+```bash packageManager="npm"
+npm install @intlayer/analytics
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/analytics
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/analytics
+```
+
+```bash packageManager="bun"
+bun add @intlayer/analytics
+```
+
+Si no lo instalas, todos los puntos de integración se resuelven como una operación nula (no-op) — consulta [Costo cero cuando no está instalado](#costo-cero-cuando-no-esta-instalado) a continuación.
+
+## Configuración
+
+Analytics **reutiliza el bloque de configuración `editor` existente** — no hay un esquema de configuración `analytics` separado que rellenar:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    backendURL: "https://back.intlayer.org", // También usado como endpoint de ingesta de analíticas
+    clientId: "your-client-id", // También usado como clave de proyecto de analíticas
+    clientSecret: "your-client-secret",
+  },
+};
+
+export default config;
+```
+
+- `editor.backendURL` — la URL base a la que se envían los eventos de analíticas (`POST {backendURL}/api/analytics/events`).
+- `editor.clientId` — la clave pública del proyecto atribuida a cada evento ingerido. También actúa como el **interruptor de encendido**: las analíticas permanecen totalmente desactivadas (y eliminadas del código final) hasta que se configura el `clientId`.
+
+Si autoalojas Intlayer, las analíticas apuntan automáticamente a tu propia instancia, ya que comparte `editor.backendURL`.
+
+## Soporte de frameworks
+
+Analytics está integrado en el `IntlayerProvider` compartido de `react-intlayer`, por lo que está disponible hoy en cualquier lugar donde se use ese proveedor:
+
+| Framework                                                | Estado                                                                                              |
+| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| React                                                    | ✅ Disponible                                                                                       |
+| Next.js (`next-intlayer`)                                | ✅ Disponible (a través de `react-intlayer`)                                                        |
+| React Native / Expo (`react-native-intlayer`)            | ✅ Disponible (a través de `react-intlayer`)                                                        |
+| Vue, Svelte, Angular, Solid, Preact, Lit, Astro, Vanilla | 🚧 Planeado — mismo cliente, enlaces a nivel de proveedor siguiendo el modelo de `@intlayer/editor` |
+
+## Uso
+
+### Seguimiento automático a nivel de proveedor
+
+No se requieren cambios en el código. Una vez que `@intlayer/analytics` está instalado y `editor.clientId` está configurado, `IntlayerProvider` automáticamente:
+
+- inicializa el cliente de analíticas al montarse,
+- registra un `page_view` en la carga inicial,
+- registra un `page_view` en cada cambio de locale,
+- inicia el ciclo de vaciado (flush) de ~20s y envía cualquier evento restante al desmontar / cerrar pestaña (vía `navigator.sendBeacon`, con respaldo a `fetch(..., { keepalive: true })`).
+
+### Seguimiento automático a nivel de nodo
+
+Cada vez que `useIntlayer` resuelve un fragmento de contenido para mostrar, el intérprete reporta un evento de `content_exposure` para esa exacta `dictionaryKey` + ruta de clave + locale — de nuevo, no se requieren cambios en el código. Las exposiciones repetidas del mismo nodo dentro de una ventana de vaciado se fusionan en un solo evento con un contador (`count`), por lo que una lista que se vuelve a renderizar 50 veces no envía 50 eventos.
+
+### Seguimiento de conversiones para pruebas A/B
+
+Usa `useConversion()` para atribuir un objetivo a la variante que vio una sesión:
+
+```tsx fileName="CTAButton.tsx" codeFormat="tsx"
+import { useConversion } from "react-intlayer";
+
+const CTAButton = () => {
+  const trackConversion = useConversion();
+
+  return (
+    <button
+      onClick={() =>
+        trackConversion({
+          experimentKey: "homepage-hero",
+          variant: "black_friday",
+          goal: "cta_click",
+        })
+      }
+    >
+      Empezar
+    </button>
+  );
+};
+```
+
+### Resolución de una variante en el lado del cliente
+
+```tsx fileName="useHeroVariant.ts" codeFormat="tsx"
+import { getGlobalAnalyticsClient } from "@intlayer/analytics/client";
+
+const client = getGlobalAnalyticsClient();
+const variant = client?.getVariant("homepage-hero", [
+  "control",
+  "black_friday",
+]);
+```
+
+## Privacidad y rendimiento
+
+- **Anónimo por diseño**: las sesiones se identifican mediante una ID rotatoria; el backend solo almacena un **hash SHA-256** de esa ID — nunca la ID en crudo, nunca una dirección IP.
+- **La ubicación es aproximada**: solo un código de país, derivado de las cabeceras de geolocalización del CDN (`cf-ipcountry`, `x-vercel-ip-country`, ...) — no se lee ni almacena ninguna IP.
+- **Las URLs excluyen los parámetros de búsqueda** por defecto, por lo que las cadenas de consulta nunca se capturan.
+- **Muestreo**: `sampleRate` te permite conservar solo una fracción de los eventos de exposición de contenido en aplicaciones con mucho tráfico.
+- **Por lotes**: una solicitud aproximadamente cada 20 segundos (`flushInterval`), o antes si el búfer se llena (`maxBufferSize`) — nunca una solicitud por evento.
+
+### Costo cero cuando no está instalado
+
+`@intlayer/analytics` sigue exactamente el mismo patrón de dependencia opcional que `@intlayer/editor`:
+
+- cada punto de integración carga el paquete a través de un **`import()` dinámico envuelto en `try/catch`** — una app que nunca instala `@intlayer/analytics` nunca paga un costo de tamaño de bundle o tiempo de ejecución, y nunca ve un error;
+- una variable de entorno en tiempo de compilación (`INTLAYER_ANALYTICS_ENABLED`), configurada automáticamente en `'false'` por `@intlayer/config` cuando `editor.clientId` no está configurado, permite a los empaquetadores **eliminar el código muerto** de toda la integración;
+- las analíticas se desactivan dentro del iframe de vista previa del editor/CMS de Intlayer, por lo que las sesiones de edición nunca se cuentan como tráfico real.
+
+## Panel de control: Página de Analíticas
+
+Una vez que tu proyecto haya recopilado eventos, la página de **Analytics** en el [panel de control de Intlayer](https://app.intlayer.org/analytics) (visible en la barra lateral una vez que se selecciona un proyecto) muestra:
+
+- **Usuarios activos** — visitantes únicos durante el período móvil seleccionado (7 / 30 / 90 días).
+- **Usuarios hoy** y **usuarios en los últimos 7 días**.
+- **Vistas de página** durante el período seleccionado.
+- Un **gráfico de evolución** de visitantes únicos diarios.
+- Pestañas de desglose de **Configuraciones regionales (Locales)** y **Ubicación**, clasificando tu audiencia por locale y por país.
+
+## Referencia de la API del Backend
+
+Todos los endpoints de lectura requieren autenticación; la ingesta es pública y se atribuye por el `clientId`.
+
+| Método | Endpoint                                    | Descripción                                                                           |
+| ------ | ------------------------------------------- | ------------------------------------------------------------------------------------- |
+| `POST` | `/api/analytics/events`                     | Ingerir un lote de eventos (público, atribuido por `clientId` en el cuerpo).          |
+| `GET`  | `/api/analytics/overview`                   | Totales de páginas/locales para el proyecto autenticado.                              |
+| `GET`  | `/api/analytics/audience?days=30`           | Visitantes únicos, vistas de página, serie diaria, desgloses por locale + país.       |
+| `GET`  | `/api/analytics/content-stats`              | Totales de exposición por contenido, agrupados por clave de diccionario/ruta/locale.  |
+| `GET`  | `/api/analytics/experiments/:experimentKey` | Tasas de conversión por variante y significancia estadística para un experimento A/B. |
+
+También puedes llamar a estos programáticamente con el [SDK del CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/intlayer_CMS.md):
+
+```ts fileName="analytics.ts"
+import { createIntlayerCMS } from "@intlayer/api";
+import { analyticsEndpoint } from "@intlayer/api/analytics";
+
+const cms = createIntlayerCMS();
+
+const { data: audience } = await analyticsEndpoint(cms).getAudience(30);
+```
+
+## Enlaces útiles
+
+- [Diccionarios Dinámicos - Colecciones y Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md)
+- [CMS de Intlayer - SDK del CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/intlayer_CMS.md)
+- [Editor Visual de Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/intlayer_visual_editor.md)
+- [Referencia de Configuración](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/configuration.md)
+- [Guía de Autoalojamiento](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/self_hosting.md)

package/docs/es/autoFill.md

@@ -75,11 +75,30 @@ En v7, el comportamiento del comando `fill` ha sido actualizado:
 
 Cuando se utiliza una opción de ruta para escribir en otro archivo, el mecanismo de completación funciona a través de una relación _maestro-esclavo_ entre archivos de declaración de contenido. El archivo principal (maestro) sirve como la fuente de verdad, y cuando se actualiza, Intlayer aplicará automáticamente esos cambios a los archivos de declaración completados (derivados) especificados por la ruta.
 
-# Traducciones de Archivos de Declaración de Contenido con Relleno Automático
+### Personalización por Locale
 
-**Los archivos de declaración de contenido con relleno automático** son una forma de acelerar tu flujo de trabajo de desarrollo.
+También puedes personalizar el comportamiento de cada locale utilizando un objeto:
 
-El mecanismo de relleno automático funciona mediante una relación _maestro-esclavo_ entre archivos de declaración de contenido. Cuando el archivo principal (maestro) se actualiza, Intlayer aplicará automáticamente esos cambios a los archivos de declaración derivados (rellenados automáticamente).
+```ts fileName="intlayer.config.ts"
+const config: IntlayerConfig = {
+  content: {
+    internationalization: {
+      locales: [Locales.ENGLISH, Locales.FRENCH, Locales.POLISH],
+      defaultLocale: Locales.ENGLISH,
+      requiredLocales: [Locales.ENGLISH], // Recomendado para evitar Property 'pl' is missing in type '{ en: string; xxx } on your t function if
+    },
+  },
+  dictionary: {
+    fill: {
+      en: true, // Llenar y editar el archivo actual para inglés
+      fr: "./translations/fr.json", // Crear archivo separado para francés
+      es: false, // Desactivar fill para español
+    },
+  },
+};
+```
+
+Esto te permite tener diferentes comportamientos de fill para diferentes locales dentro del mismo proyecto.
 
 ```ts fileName="src/components/example/example.content.ts"
 import { Locales, type Dictionary } from "intlayer";
@@ -87,16 +106,16 @@ import { Locales, type Dictionary } from "intlayer";
 const exampleContent = {
   key: "example",
   locale: Locales.ENGLISH,
-  autoFill: "./example.content.json",
+  fill: "./example.content.json",
   content: {
-    contentExample: "Este es un ejemplo de contenido",
+    contentExample: "This is an example of content",
   },
 } satisfies Dictionary;
 
 export default exampleContent;
 ```
 
-Aquí hay un [archivo de declaración de contenido por idioma](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/per_locale_file.md) que usa la instrucción `autoFill`.
+Aquí hay un [archivo de declaración de contenido por locale](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/per_locale_file.md) usando la instrucción `fill`.
 
 Luego, cuando ejecutes el siguiente comando:
 
@@ -116,7 +135,7 @@ pnpm intlayer fill --file 'src/components/example/example.content.ts'
 bun x intlayer fill --file 'src/components/example/example.content.ts'
 ```
 
-Intlayer generará automáticamente el archivo de declaración derivado en `src/components/example/example.content.json`, completando todos los locales que no estén ya declarados en el archivo principal.
+Intlayer generará automáticamente el archivo de declaración derivado en `src/components/example/example.content.json`, llenando todos los locales que aún no estén declarados en el archivo principal.
 
 ```json5 fileName="src/components/example/example.content.json"
 {
@@ -125,15 +144,15 @@ Intlayer generará automáticamente el archivo de declaración derivado en `src/
     "contentExample": {
       "nodeType": "translation",
       "translation": {
-        "fr": "Ceci est un exemple de contenu",
         "es": "Este es un ejemplo de contenido",
+        "fr": "Ceci est un exemple de contenu",
       },
     },
   },
 }
 ```
 
-Después, ambos archivos de declaración se fusionarán en un único diccionario, accesible mediante el hook estándar `useIntlayer("example")` (react) / composable (vue).
+Posteriormente, ambos archivos de declaración se fusionarán en un único diccionario, accesible mediante el hook `useIntlayer("example")` estándar (react) / composable (vue).
 
 ## Configuración Global
 

package/docs/es/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-07-11
+updatedAt: 2026-08-06
 title: Configuración (Configuration)
 description: Aprenda a configure Intlayer para su aplicación. Entienda los diversos ajustes y opciones disponibles para personalizar Intlayer según sus necesidades.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 9.1.3
+    date: 2026-08-06
+    changes: "Hacer `routing.enableProxy` de tres estados: sin definir (auto), `true`, `false`"
   - version: 9.0.0
     date: 2026-07-11
     changes: "Se añadió la configuración `analytics`"
@@ -235,6 +238,19 @@ const config: IntlayerConfig = {
      */
     mode: "prefix-no-default",
 
+    /**
+     * Activa el proxy de enrutamiento de locales de Intlayer (middleware).
+     * Gestiona la detección de locale, redirecciones y reescrituras en dev, preview y SSR.
+     * - sin definir (auto): los servidores de dev y preview mantienen el enrutamiento
+     *   guiado por la URL ignorando el locale almacenado en cookies y cabeceras.
+     *   Los prefijos se siguen resolviendo, el locale se sigue persistiendo y la
+     *   detección Accept-Language se sigue aplicando. En producción se comporta como `true`.
+     * - true: comportamiento completo en todos los entornos.
+     * - false: sin enrutamiento de locales.
+     * Por defecto: undefined (auto)
+     */
+    enableProxy: undefined,
+
     /**
      * Dónde almacenar la localidad seleccionada por el usuario.
      * Opciones: 'cookie', 'localStorage', 'sessionStorage', 'header' o una combinación de estos.
@@ -716,12 +732,13 @@ Las analíticas son estrictamente opcionales (opt-in): no se recopila nada a men
 
 Ajustes que controlan el comportamiento del enrutamiento, incluida la estructura de la URL, el almacenamiento de localidades y el manejo del middleware.
 
-| Campo      | Descripción                                                                                                                                                  | Tipo                                                                                                                                                                                                         | Predeterminado         | Ejemplo                                                                                                                                                                                         | Nota                                                                                                                                                                                                                                                                                                              |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mode`     | Modo de enrutamiento de URL para el manejo de localidades (locales).                                                                                         | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) o `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: localidad manejada por otros medios. `'search-params'`: `/dashboard?locale=fr` | No afecta la gestión de galletas (cookies) o el almacenamiento de localidades.                                                                                                                                                                                                                                    |
-| `storage`  | Configuración para almacenar la localidad (locale) en el cliente.                                                                                            | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                              | Consulte la tabla de Opciones de Almacenamiento más abajo.                                                                                                                                                                                                                                                        |
-| `basePath` | Ruta base para las URL de la aplicación.                                                                                                                     | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                     | Si la aplicación está en `https://example.com/my-app`, basePath es `'/my-app'` y las URL se convierten en `https://example.com/my-app/en`.                                                                                                                                                                        |
-| `rewrite`  | Reglas de reescritura de URL personalizadas que anulan el modo de enrutamiento predeterminado para rutas específicas. Admite parámetros dinámicos `[param]`. | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Ver ejemplo abajo                                                                                                                                                                               | • Las reglas de reescritura tienen prioridad sobre `mode`.<br/>• Funciona con Next.js y Vite.<br/>• `getLocalizedUrl()` aplica automáticamente las reglas correspondientes.<br/>• Ver [Reescrituras de URL Personalizadas](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/custom_url_rewrites.md). |
+| Campo         | Descripción                                                                                                                                                  | Tipo                                                                                                                                                                                                         | Predeterminado         | Ejemplo                                                                                                                                                                                         | Nota                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `mode`        | Modo de enrutamiento de URL para el manejo de localidades (locales).                                                                                         | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) o `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: localidad manejada por otros medios. `'search-params'`: `/dashboard?locale=fr` | No afecta la gestión de galletas (cookies) o el almacenamiento de localidades.                                                                                                                                                                                                                                                                                                                                                       |
+| `enableProxy` | Activa el proxy de enrutamiento de locales de Intlayer (middleware).                                                                                         | `boolean` &#124; <br/> `undefined`                                                                                                                                                                           | `undefined` (auto)     | `true`                                                                                                                                                                                          | • Sin definir (auto): los servidores de dev y preview ignoran el locale almacenado en cookies/cabeceras como fuente de redirección; los prefijos, la persistencia y la detección `Accept-Language` se siguen aplicando. En producción se comporta como `true`.<br/>• `true`: comportamiento completo en todas partes.<br/>• `false`: sin enrutamiento de locales. En Next.js, el middleware `intlayerProxy` pasa a ser transparente. |
+| `storage`     | Configuración para almacenar la localidad (locale) en el cliente.                                                                                            | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                              | Consulte la tabla de Opciones de Almacenamiento más abajo.                                                                                                                                                                                                                                                                                                                                                                           |
+| `basePath`    | Ruta base para las URL de la aplicación.                                                                                                                     | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                     | Si la aplicación está en `https://example.com/my-app`, basePath es `'/my-app'` y las URL se convierten en `https://example.com/my-app/en`.                                                                                                                                                                                                                                                                                           |
+| `rewrite`     | Reglas de reescritura de URL personalizadas que anulan el modo de enrutamiento predeterminado para rutas específicas. Admite parámetros dinámicos `[param]`. | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Ver ejemplo abajo                                                                                                                                                                               | • Las reglas de reescritura tienen prioridad sobre `mode`.<br/>• Funciona con Next.js y Vite.<br/>• `getLocalizedUrl()` aplica automáticamente las reglas correspondientes.<br/>• Ver [Reescrituras de URL Personalizadas](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/custom_url_rewrites.md).                                                                                                                    |
 
 **Ejemplo de `rewrite`**:
 

package/docs/es/dictionary/file.md

@@ -23,7 +23,9 @@ history:
 author: aymericzip
 ---
 
-# Contenido de Archivo / Incrustar Archivos en Intlayer
+# Contenido de Archivo / Integración de Archivos en Intlayer
+
+En Intlayer, la función `file` permite incrustar contenido de archivos externos en un diccionario. Este enfoque garantiza que Intlayer reconozca el archivo fuente, permitiendo una integración fluida con el Editor Visual de Intlayer y CMS.
 
 ## Cómo Funciona la Incrustación de Archivos
 

package/docs/es/dictionary/nesting.md

@@ -64,6 +64,53 @@ export default firstDictionary;
 }
 ```
 
+### Referencing with Nest
+
+Ahora, crea otro módulo de contenido que use la función `nest` para referenciar el contenido anterior. Puedes referenciar el contenido completo o un valor anidado específico:
+
+```typescript fileName="secondDictionary.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { nest, type Dictionary } from "intlayer";
+
+const myNestingContent = {
+  key: "key_of_my_second_dictionary",
+  content: {
+    // Referencia el diccionario completo:
+    fullNestedContent: nest("key_of_my_first_dictionary"),
+    // Referencia un valor anidado específico:
+    partialNestedContent: nest(
+      "key_of_my_first_dictionary",
+      "subContent.contentNumber"
+    ),
+  },
+} satisfies Dictionary;
+
+export default myNestingContent;
+```
+
+```json fileName="secondDictionary.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "key_of_my_second_dictionary",
+  "content": {
+    "fullNestedContent": {
+      "nodeType": "nested",
+      "nested": {
+        "dictionaryKey": "key_of_my_first_dictionary"
+      }
+    },
+    "partialNestedContent": {
+      "nodeType": "nested",
+      "nested": {
+        "dictionaryKey": "key_of_my_first_dictionary",
+        "path": "subContent.contentNumber"
+      }
+    }
+  }
+}
+```
+
+Como segundo parámetro, puedes especificar una ruta a un valor anidado dentro de ese contenido. Cuando no se proporciona ninguna ruta, se devuelve el contenido completo del diccionario referenciado.
+
 ## Configuración de la Anidación
 
 <Tabs group="framework">
@@ -258,36 +305,6 @@ document.getElementById("nested")!.textContent = content.partialNestedContent;
   </Tab>
 </Tabs>
 
-## Usando Anidación con React Intlayer
-
-Para usar contenido anidado en un componente de React, utiliza el hook `useIntlayer` del paquete `react-intlayer`. Este hook recupera el contenido correcto basado en la clave especificada. Aquí tienes un ejemplo de cómo usarlo:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { useIntlayer } from "react-intlayer";
-
-const NestComponent: FC = () => {
-  const { fullNestedContent, partialNestedContent } = useIntlayer(
-    "key_of_my_second_dictionary"
-  );
-
-  return (
-    <div>
-      <p>
-        Contenido Anidado Completo: {JSON.stringify(fullNestedContent)}
-        {/* Salida: {"content": "content", "subContent": {"contentNumber": 0, "contentString": "string"}} */}
-      </p>
-      <p>
-        Valor Anidado Parcial: {partialNestedContent}
-        {/* Salida: 0 */}
-      </p>
-    </div>
-  );
-};
-
-export default NestComponent;
-```
-
 ## Recursos Adicionales
 
 Para obtener información más detallada sobre la configuración y el uso, consulta los siguientes recursos: