@intlayer/docs 8.12.5-canary.0 → 9.0.0-canary.3

package/docs/es/plugins/sync-json.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-03-13
-updatedAt: 2025-12-13
+updatedAt: 2026-06-21
 title: Plugin de sincronización JSON
 description: Sincroniza los diccionarios de Intlayer con archivos JSON i18n de terceros (i18next, next-intl, react-intl, vue-i18n y más). Mantén tu i18n existente mientras usas Intlayer para gestionar, traducir y probar tus mensajes.
 keywords:
@@ -24,6 +24,9 @@ slugs:
   - sync-json
 youtubeVideo: https://www.youtube.com/watch?v=MpGMxniDHNg
 history:
+  - version: 9.0.0
+    date: 2026-06-21
+    changes: "Añadida opción splitKeys (un diccionario por clave de espacio de nombres de nivel superior) para diseños de archivo único de next-intl / react-intl"
   - version: 7.5.0
     date: 2025-12-13
     changes: "Añadido soporte para formatos ICU e i18next"
@@ -62,7 +65,63 @@ pnpm add -D @intlayer/sync-json-plugin
 npm i -D @intlayer/sync-json-plugin
 ```
 
-## Inicio rápido
+## Plugins
+
+Este paquete proporciona dos plugins:
+
+- `loadJSON`: Carga archivos JSON en diccionarios de Intlayer.
+  - Este plugin se utiliza para cargar archivos JSON desde una fuente y se cargará en los diccionarios de Intlayer. Puede escanear toda la base de código y buscar archivos JSON específicos.
+    Este plugin se puede utilizar
+    - si utilizas una biblioteca i18n que impone una ubicación específica para que se carguen tus JSON (ej: `next-intl`, `i18next`, `react-intl`, `vue-i18n`, etc.), pero quieres colocar tu declaración de contenido donde quieras en tu base de código.
+    - También se puede utilizar si quieres obtener tus mensajes de una fuente remota (ej: un CMS, una API, etc.) y almacenar tus mensajes en archivos JSON.
+
+  > Bajo el capó, este plugin escaneará toda la base de código y buscará archivos JSON específicos y los cargará en los diccionarios de Intlayer.
+  > Ten en cuenta que este plugin no escribirá la salida y las traducciones de vuelta a los archivos JSON.
+
+- `syncJSON`: Sincroniza archivos JSON con diccionarios de Intlayer.
+  - Este plugin se utiliza para sincronizar archivos JSON con diccionarios de Intlayer. Puede escanear la ubicación dada y cargar los JSON que coincidan con el patrón para archivos JSON específicos. Este plugin es útil si quieres obtener los beneficios de Intlayer mientras usas otra biblioteca i18n.
+
+## Usando ambos plugins
+
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON, syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  // Mantén tus archivos JSON actuales sincronizados con los diccionarios de Intlayer
+  plugins: [
+    /**
+     * Cargará todos los archivos JSON en src que coincidan con el patrón {key}.i18n json
+     */
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      locale: Locales.ENGLISH,
+      priority: 1, // Asegura que estos archivos JSON tengan precedencia sobre los archivos en `./locales/en/${key}.json`
+      format: "intlayer", // Formato del contenido JSON
+    }),
+    /**
+     * Cargará y escribirá la salida y las traducciones de vuelta a los archivos JSON en el directorio locales
+     */
+    syncJSON({
+      format: "i18next",
+      source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      priority: 0,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
+```
+
+## `syncJSON` plugin
+
+### Inicio rápido
 
 Agrega el plugin a tu `intlayer.config.ts` y apúntalo a tu estructura JSON existente.
 
@@ -81,6 +140,7 @@ const config: IntlayerConfig = {
     syncJSON({
       // Diseño por idioma, por espacio de nombres (por ejemplo, next-intl, i18next con espacios de nombres)
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      format: "icu",
     }),
   ],
 };
@@ -91,14 +151,27 @@ export default config;
 Alternativa: archivo único por idioma (común en configuraciones i18next/react-intl):
 
 ```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+import { Locales, type IntlayerConfig } from "intlayer";
+import { syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  plugins: [
+    syncJSON({
+      format: "i18next",
+      source: ({ locale }) => `./locales/${locale}.json`,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
 ```
 
-### Cómo funciona
+#### Cómo funciona
 
 - Lectura: el plugin descubre archivos JSON desde tu generador `source` y los carga como diccionarios de Intlayer.
 - Escritura: después de las compilaciones y llenados, escribe los JSON localizados de vuelta en las mismas rutas (con una nueva línea final para evitar problemas de formato).
@@ -112,6 +185,7 @@ syncJSON({
   location?: string, // etiqueta opcional, por defecto: "plugin"
   priority?: number, // prioridad opcional para resolución de conflictos, por defecto: 0
   format?: 'intlayer' | 'icu' | 'i18next', // formateador opcional, usado para compatibilidad con el runtime de Intlayer
+  splitKeys?: boolean, // opcional, divide un solo archivo en un diccionario por clave de espacio de nombres de nivel superior (autodetectado)
 });
 ```
 
@@ -136,17 +210,49 @@ syncJSON({
 }),
 ```
 
-## Múltiples fuentes JSON y prioridad
+#### `splitKeys` (boolean)
+
+Controla si un único archivo JSON cuyas **claves de primer nivel son espacios de nombres** debe convertirse en un diccionario por cada clave de nivel superior, en lugar de un único diccionario que contenga todo el archivo.
+
+Esto coincide con el modelo de espacio de nombres de bibliotecas como `next-intl` y `react-intl`, donde un archivo `messages/{locale}.json` agrupa varios espacios de nombres por sus claves de primer nivel, cada uno abordado de forma independiente (por ejemplo, `useTranslations('Hero')` se resuelve en el diccionario `Hero`).
+
+- `undefined` (por defecto): **autodetectado** — el archivo se divide cuando el patrón `source` no tiene un segmento `{key}` (un archivo contiene todos los espacios de nombres), y se mantiene como un único diccionario en caso contrario (un archivo por clave).
+- `true`: siempre divide cada clave de nivel superior en su propio diccionario.
+- `false`: nunca divide; todo el archivo se convierte en un único diccionario.
+
+Dado un único archivo `messages/{locale}.json`:
+
+```json fileName="messages/en.json"
+{
+  "Hero": { "title": "Full-stack developer" },
+  "Nav": { "work": "Work", "about": "About" },
+  "About": { "lead": "I build apps end to end." }
+}
+```
+
+```ts fileName="intlayer.config.ts"
+syncJSON({
+  format: "icu",
+  source: ({ locale }) => `./messages/${locale}.json`,
+  // splitKeys: true, // implícito porque el patrón no tiene un segmento `{key}`
+}),
+```
+
+Esto produce tres diccionarios — `Hero`, `Nav` y `About` — por lo que `useTranslations('Hero')` (next-intl) se resuelve correctamente. Al volver a escribir, todos los espacios de nombres se reensamblan en el mismo archivo por localidad.
+
+> Cuando mantienes el segmento `{key}` explícito en tu `source` (por ejemplo, `./locales/${locale}/${key}.json`), cada archivo ya es un espacio de nombres, por lo que la división está deshabilitada por defecto.
+
+### Múltiples fuentes JSON y prioridad
 
 Puedes agregar múltiples plugins `syncJSON` para sincronizar diferentes fuentes JSON. Esto es útil cuando tienes múltiples bibliotecas i18n o diferentes estructuras JSON en tu proyecto.
 
-### Sistema de prioridad
+#### Sistema de prioridad
 
 Cuando múltiples plugins apuntan a la misma clave del diccionario, el parámetro `priority` determina qué plugin tiene precedencia:
 
 - Los números de prioridad más altos ganan sobre los más bajos
 - La prioridad por defecto de los archivos `.content` es `0`
-- La prioridad por defecto de los archivos de contenido de plugins es `-1`
+- La prioridad por defecto de los plugins es `0`
 - Los plugins con la misma prioridad se procesan en el orden en que aparecen en la configuración
 
 ```ts fileName="intlayer.config.ts"
@@ -189,73 +295,140 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-### Resolución de conflictos
+## Load JSON plugin
 
-Cuando la misma clave de traducción existe en múltiples fuentes JSON:
+### Inicio rápido
 
-1. El plugin con la prioridad más alta determina el valor final
-2. Las fuentes con menor prioridad se usan como respaldo para claves faltantes
-3. Esto permite mantener traducciones heredadas mientras se migra gradualmente a nuevas estructuras
+Agrega el plugin a tu `intlayer.config.ts` para ingerir archivos JSON existentes como diccionarios de Intlayer. Este plugin es de solo lectura (no escribe en disco):
 
-## Integraciones
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-A continuación se muestran mapeos comunes. Mantén tu entorno de ejecución sin cambios; solo agrega el plugin.
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
 
-### i18next
+  plugins: [
+    // Ingerir mensajes JSON ubicados en cualquier parte de tu árbol de código fuente
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      // Cargar una sola localidad por instancia de plugin (por defecto a la localidad predeterminada de la configuración)
+      locale: Locales.ENGLISH,
+      priority: 0,
+    }),
+  ],
+};
 
-Disposición típica de archivos: `./public/locales/{locale}/{namespace}.json` o `./locales/{locale}/{namespace}.json`.
+export default config;
+```
+
+Alternativa: diseño por localidad, aún de solo lectura (solo se carga la localidad seleccionada):
 
 ```ts fileName="intlayer.config.ts"
-import { syncJSON } from "@intlayer/sync-json-plugin";
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-export default {
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
   plugins: [
-    syncJSON({
-      format: "i18next",
+    loadJSON({
+      // Solo los archivos para Locales.FRENCH se cargarán desde este patrón
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      locale: Locales.FRENCH,
     }),
   ],
 };
+
+export default config;
 ```
 
-### next-intl
+### Cómo funciona
 
-Mensajes JSON por localidad (a menudo `./messages/{locale}.json`) o por espacio de nombres.
+- Descubrir: construye un glob a partir de tu generador `source` y recopila los archivos JSON coincidentes.
+- Ingerir: carga cada archivo JSON como un diccionario de Intlayer con la `locale` proporcionada.
+- Solo lectura: no escribe ni formatea archivos de salida; usa `syncJSON` si necesitas sincronización de ida y vuelta.
+- Listo para auto‑relleno: define un patrón `fill` para que `intlayer content fill` pueda rellenar las claves faltantes.
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale, key }) => `./messages/${locale}/${key}.json`,
-  }),
-];
+### API
+
+```ts
+loadJSON({
+  // Construye rutas a tu JSON. `locale` es opcional si tu estructura no tiene un segmento de localidad
+  source: ({ key, locale }) => string,
+
+  // Localidad objetivo para los diccionarios cargados por esta instancia de plugin
+  // Por defecto a configuration.internationalization.defaultLocale
+  locale?: Locale,
+
+  // Etiqueta opcional para identificar la fuente
+  location?: string, // default: "plugin"
+
+  // Prioridad utilizada para la resolución de conflictos contra otras fuentes
+  priority?: number, // default: 0
+
+  // Formateador opcional para el contenido JSON
+  format?: 'intlayer' | 'icu' | 'i18next', // default: 'intlayer'
+
+  // Divide un solo archivo en un diccionario por clave de nivel superior (autodetectado)
+  splitKeys?: boolean,
+});
 ```
 
-Véase también: `docs/es/intlayer_with_next-intl.md`.
+#### `format` ('intlayer' | 'icu' | 'i18next')
 
-### react-intl
+Especifica el formateador a utilizar para el contenido del diccionario al cargar archivos JSON. Esto permite usar diferentes sintaxis de formateo de mensajes compatibles con varias bibliotecas i18n.
 
-Es común un único JSON por localidad:
+- `'intlayer'`: El formateador Intlayer por defecto (por defecto).
+- `'icu'`: Usa el formateo de mensajes ICU (compatible con bibliotecas como react-intl, vue-i18n).
+- `'i18next'`: Usa el formateo de mensajes i18next (compatible con i18next, next-i18next, Solid-i18next).
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+**Ejemplo:**
+
+```ts
+loadJSON({
+  source: ({ key }) => `./src/**/${key}.i18n.json`,
+  locale: Locales.ENGLISH,
+  format: "icu", // Usar formateo ICU para compatibilidad
+}),
 ```
 
-### vue-i18n
+#### `splitKeys` (boolean)
 
-Puede ser un solo archivo por locale o por namespace:
+Mismo comportamiento que en [`syncJSON`](#splitkeys-boolean): cuando un único archivo JSON agrupa varios espacios de nombres por sus claves de primer nivel, cada clave de nivel superior se convierte en su propio diccionario.
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ key, locale }) => `./src/locales/${locale}/${key}.json`,
-  }),
-];
+- `undefined` (por defecto): **autodetectado** — se divide cuando el patrón `source` no tiene un segmento `{key}`, un único diccionario en caso contrario.
+- `true` / `false`: fuerza o deshabilita la división.
+
+```ts
+loadJSON({
+  source: ({ locale }) => `./messages/${locale}.json`,
+  format: "icu",
+  // splitKeys auto-enabled: `Hero`, `Nav`, `About`, … cada uno se convierte en un diccionario
+}),
 ```
 
+### Comportamiento y convenciones
+
+- Si tu máscara `source` incluye un marcador de posición de localidad, solo se ingieren los archivos para la `locale` seleccionada.
+- Si no hay un segmento `{key}` en tu máscara, cada clave de nivel superior del archivo se convierte en su propio diccionario por defecto (ver [`splitKeys`](#splitkeys-boolean)). Establece `splitKeys: false` para cargar en su lugar todo el archivo como un único diccionario `index`.
+- Las claves se derivan de las rutas de los archivos sustituyendo el marcador de posición `{key}` en tu generador `source`.
+- El plugin solo utiliza los archivos descubiertos y no fabrica localidades o claves faltantes.
+- La ruta `fill` se infiere de tu `source` y se utiliza para actualizar los valores faltantes a través de la CLI cuando optas por ello.
+
+## Resolución de conflictos
+
+Cuando la misma clave de traducción existe en múltiples fuentes JSON:
+
+1. El plugin con la prioridad más alta determina el valor final
+2. Las fuentes con menor prioridad se usan como respaldo para claves faltantes
+3. Esto permite mantener traducciones heredadas mientras se migra gradualmente a nuevas estructuras
+
 ## CLI
 
 Los archivos JSON sincronizados serán considerados como otros archivos `.content`. Eso significa que todos los comandos de intlayer estarán disponibles para los archivos JSON sincronizados. Incluyendo:

package/docs/es/releases/v8.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-22
-updatedAt: 2026-01-26
+updatedAt: 2026-06-14
 title: Nuevo Intlayer v8 - ¿Qué hay de nuevo?
 description: Descubre qué hay de nuevo en Intlayer v8. Mejoras importantes en la experiencia del desarrollador, validación de contenido y gestión de diccionarios.
 keywords:
@@ -409,6 +409,16 @@ Para más detalles, consulte la [Documentación de Contenido HTML](https://githu
 
 ---
 
+## Archivos de Contenido YAML y Markdown (v8.10.0)
+
+Ahora puede declarar contenido directamente utilizando las extensiones de archivo `.content.md` y `.content.yaml`. Esto es perfecto para contenido de formato largo, blogs, documentación y políticas de privacidad.
+
+Estos archivos son completamente editables desde el Editor Visual, lo que proporciona un flujo de trabajo optimizado para los miembros del equipo no técnicos.
+
+Para más detalles, consulte la [Documentación de Archivos de Contenido YAML](https://intlayer.org/doc/concept/content#yaml-content-file) y la [Documentación de Archivos de Contenido Markdown](https://intlayer.org/doc/concept/content/markdown).
+
+---
+
 ## Reescrituras de URL personalizadas
 
 Intlayer v8 introduce el soporte para **Reescrituras de URL personalizadas**, lo que le permite definir rutas específicas de locale que difieren de la estructura estándar `/locale/path`. Esta es una característica poderosa para mejorar el SEO local y proporcionar una experiencia de usuario más natural para los hablantes no ingleses.
@@ -753,6 +763,58 @@ export default {
   </Tab>
 </Tabs>
 
+## Reglas de Pluralización Unicode CLDR (v8.8.0)
+
+Se ha introducido un nuevo helper de nodo `plural` basado en las reglas de pluralización definidas por el Proyecto Unicode CLDR, mejorando el soporte para idiomas complejos.
+
+```typescript fileName="src/openings.content.ts"
+import { plural, t, type Dictionary } from "intlayer";
+
+const openingsContent = {
+  key: "total_openings",
+  content: {
+    totalOpenings: t({
+      en: plural({
+        one: "{{count}} opening",
+        other: "{{count}} openings",
+      }),
+      fr: plural({
+        one: "{{count}} offre",
+        other: "{{count}} offres",
+      }),
+    }),
+  },
+} satisfies Dictionary;
+
+export default openingsContent;
+```
+
+Luego puede pasar el conteo dinámicamente en el componente de su framework:
+
+```tsx
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const OpeningsComponent: FC<{ count: number }> = ({ count }) => {
+  const { totalOpenings } = useIntlayer("total_openings");
+
+  return (
+    <div>
+      {/* En inglés:                                  */}
+      {/*  count=0  → "0 openings"   (other)           */}
+      {/*  count=1  → "1 opening"    (one)             */}
+      {/*  count=2  → "2 openings"   (other)           */}
+      {/*  count=21 → "21 openings"  (other)           */}
+      <p>{totalOpenings(count)}</p>
+    </div>
+  );
+};
+```
+
+Para más información, consulte la [Documentación de Pluralización](https://intlayer.org/doc/concept/content/plural).
+
+---
+
 ## Validación del esquema de contenido
 
 Intlayer v8 introduce la validación de esquemas para diccionarios. Ahora puede definir esquemas de validación reutilizables en su configuración utilizando Zod y aplicarlos a sus archivos de contenido. Esto garantiza que su contenido siempre se adhiera a la estructura esperada, detectando errores en el momento de la construcción.
@@ -797,6 +859,34 @@ Si el contenido no coincide con el esquema (por ejemplo, el título es demasiado
 
 ---
 
+## TypeScript: Accesores Primitivos de IntlayerNode
+
+El tipo `IntlayerNode` ha sido actualizado para permitir llamar métodos primitivos de JavaScript directamente en los nodos de contenido. Esto hace posible interactuar con su contenido localizado directamente como si fuera un primitivo estándar de cadena, número, booleano o array.
+
+Compatible con React, Preact, Solid, Svelte, Vue y Angular.
+
+### Ejemplo de Cadena
+
+```typescript
+content.placeholder; // Returns IntlayerNode<string>
+content.placeholder.value; // Returns string
+content.placeholder.toString(); // Returns string
+content.placeholder.toLowerCase(); // Returns string
+String(content.placeholder); // Returns string
+content.placeholder.toUpperCase(); // Returns uppercased string
+content.placeholder.replace("a", "b"); // Returns modified string
+```
+
+### Ejemplo de Array
+
+```typescript
+content.myArrayOfString             // Returns IntlayerNode<Array<string>>
+content.myArrayOfString.find(...)   // Returns element
+content.myArrayOfString.join(', ')  // Returns joined string
+```
+
+---
+
 ### Detección automática de contenido mejorada
 
 En la v8, Intlayer detecta inteligentemente la sintaxis Markdown, las etiquetas HTML y las inserciones de variables en sus cadenas de contenido. Esto significa que a menudo puede omitir funciones auxiliares como `md()`, `html()` o `insert()`.
@@ -1002,6 +1092,17 @@ La extensión de Intlayer para VSCode recibe actualizaciones importantes en la v
 
 ---
 
+## Herramientas: Watcher de C++ y LSP basado en OXC (v8.12.0)
+
+Intlayer v8.12.0 trae importantes mejoras a la experiencia del desarrollador:
+
+- **Parcel Watcher**: El observador de contenido ha sido migrado de `chokidar` a `@parcel/watcher`, aprovechando la observación de archivos nativa de C++ para proporcionar actualizaciones más rápidas y un consumo de memoria significativamente menor.
+- **Nuevo Protocolo de Servidor de Lenguaje (LSP)**: Un LSP completamente nuevo ya está disponible. Construido con parsing basado en OXC, ayuda a su IDE y agentes de IA a vincular sin problemas las llamadas a `useIntlayer('my-key')` con sus archivos `.content` correspondientes, y viceversa.
+
+Para más detalles, consulte la [Documentación de LSP](https://intlayer.org/doc/lsp).
+
+---
+
 ## Optimizaciones del compilador
 
 Intlayer v8 incluye una nueva capa de almacenamiento en caché para el compilador de Markdown y HTML. Esto garantiza que las cadenas de contenido idénticas con la misma configuración solo se analicen una vez, lo que reduce significativamente la sobrecarga durante los re-renderizados o cuando se utiliza el mismo contenido en varios lugares.
@@ -1057,6 +1158,48 @@ Intlayer v8 incluye una nueva capa de almacenamiento en caché para el compilado
 
 ---
 
+## Optimizaciones Experimentales de Construcción: Minify y Purge (v8.7.0)
+
+Intlayer v8.7.0 introduce nuevas características experimentales de construcción en su `intlayer.config.ts` diseñadas para optimizar su bundle de producción:
+
+- **Minificación de Diccionarios**: Minifica los archivos de diccionario para reducir su tamaño.
+- **Purga de Claves No Utilizadas**: Escanea y elimina las claves de traducción no utilizadas de los diccionarios, renombrando las claves activas a caracteres cortos (por ejemplo, `"products" -> "a"`, `"pricing" -> "b"`). Esto reduce el tamaño del bundle hasta en un 5%.
+- **Deshabilitar Verificaciones de TypeScript**: Acelera las construcciones deshabilitando la verificación de tipos de TypeScript durante el paso de compilación.
+
+```typescript fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  dictionary: {
+    importMode: "dynamic",
+  },
+  build: {
+    /**
+     * Minify the dictionaries to reduce the bundle size.
+     */
+    minify: true,
+
+    /**
+     * Purge the unused keys in dictionaries
+     */
+    purge: true,
+
+    /**
+     * Indicates if the build should check TypeScript types
+     */
+    checkTypes: false,
+  },
+};
+
+export default config;
+```
+
+---
+
 ## Flexibilidad: Modo de Importación Unificado
 
 La propiedad booleana `live` ha sido marcada como obsoleta en favor de una propiedad `importMode` más completa. Esto permite una definición explícita de cómo deben cargarse los diccionarios: de forma estática, dinámica o mediante sincronización en vivo.
@@ -1204,6 +1347,49 @@ El contenido Markdown y HTML en Svelte ahora se analiza automáticamente a HTML
 
 ---
 
+## Soporte para Angular: Bundler Vite (v8.11.0)
+
+Para los usuarios de Angular, Intlayer ahora soporta de forma nativa el bundler Vite a través de un nuevo plugin personalizado de esbuild, acelerando los tiempos de desarrollo y construcción.
+
+Para detalles sobre la configuración, consulte la [Documentación del Entorno de Angular](https://intlayer.org/doc/environment/angular).
+
+---
+
+## Generación de Sitemap (v8.6.0)
+
+Intlayer ahora genera sitemaps automáticamente basándose en sus locales y modo de enrutamiento. Esto es particularmente útil para la optimización SEO en arquitecturas de enrutadores como TanStack Router:
+
+```typescript fileName="src/routes/sitemap.xml.ts"
+import { createFileRoute } from "@tanstack/react-router";
+import { generateSitemap } from "intlayer";
+
+const SITE_URL = (
+  import.meta.env.VITE_SITE_URL ?? "http://localhost:3000"
+).replace(/\/$/, "");
+
+export const Route = createFileRoute("/sitemap.xml")({
+  server: {
+    handlers: {
+      GET: async () => {
+        const sitemap = generateSitemap(
+          [
+            { path: "/", changefreq: "daily", priority: 1.0 },
+            { path: "/about", changefreq: "monthly", priority: 0.8 },
+          ],
+          { siteUrl: SITE_URL }
+        );
+
+        return new Response(sitemap, {
+          headers: { "Content-Type": "application/xml" },
+        });
+      },
+    },
+  },
+});
+```
+
+---
+
 ## Notas de migración desde v7
 
 ### Cambios en la configuración