@intlayer/docs 9.0.0-canary.5 → 9.0.0-canary.7

package/docs/es/packages/react-native-intlayer/exports.md

@@ -1,8 +1,8 @@
 ---
 createdAt: 2026-01-21
-updatedAt: 2026-01-21
+updatedAt: 2026-06-25
 title: Documentación del paquete react-native-intlayer
-description: Soporte para React Native de Intlayer, que proporciona providers y polyfills.
+description: Soporte para React Native de Intlayer, que proporciona providers, hooks, polyfills y configuración de Metro.
 keywords:
   - react-native-intlayer
   - react-native
@@ -14,6 +14,9 @@ slugs:
   - react-native-intlayer
   - exports
 history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Re-exportar la API completa de react-intlayer (hooks, utilidades, subpaths de format/html/markdown) para que una aplicación React Native solo dependa de react-native-intlayer"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Documentación unificada para todas las exportaciones"
@@ -22,7 +25,9 @@ author: aymericzip
 
 # Paquete react-native-intlayer
 
-El paquete `react-native-intlayer` proporciona las herramientas necesarias para integrar Intlayer en aplicaciones React Native. Incluye un provider y polyfills para el soporte de locales.
+El paquete `react-native-intlayer` proporciona las herramientas necesarias para integrar Intlayer en aplicaciones React Native. Re-exporta la API completa de `react-intlayer` (hooks y utilidades) con un `IntlayerProvider` listo para React Native, además de los polyfills y la configuración de Metro que requiere React Native.
+
+> En una aplicación React Native, importa **todo** desde `react-native-intlayer`. No necesitas instalar ni importar `react-intlayer` directamente.
 
 ## Instalación
 
@@ -34,14 +39,30 @@ npm install react-native-intlayer
 
 ### Proveedor
 
-| Componente         | Descripción                                                                           |
-| ------------------ | ------------------------------------------------------------------------------------- |
-| `IntlayerProvider` | Componente Provider que envuelve tu aplicación y proporciona el contexto de Intlayer. |
+| Componente         | Descripción                                                                                                                            |
+| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `IntlayerProvider` | Componente Provider que envuelve tu aplicación y proporciona el contexto de Intlayer. Aplica automáticamente los polyfills necesarios. |
+
+```tsx
+import { IntlayerProvider } from "react-native-intlayer";
+```
+
+### Hooks y utilidades
+
+Estos se re-exportan desde `react-intlayer`, por lo que puedes importarlos directamente desde `react-native-intlayer`:
 
-Importación:
+| Exportación                                                                                                       | Descripción                                                   |
+| ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
+| `useIntlayer`                                                                                                     | Accede al contenido localizado para una clave de diccionario. |
+| `useLocale`                                                                                                       | Lee y cambia el locale actual.                                |
+| `useDictionary`, `useDictionaryAsync`, `useDictionaryDynamic`, `useLoadDynamic`                                   | Carga el contenido del diccionario de diversas formas.        |
+| `useI18n`                                                                                                         | Hook compatible con i18next.                                  |
+| `t`                                                                                                               | Ayudante de traducción en línea.                              |
+| `getIntlayer`, `getDictionary`                                                                                    | Obtención de contenido imperativa.                            |
+| `localeCookie`, `localeInStorage`, `setLocaleCookie`, `setLocaleInStorage`, `useLocaleCookie`, `useLocaleStorage` | Ayudantes de persistencia de locale.                          |
 
 ```tsx
-import "react-native-intlayer";
+import { useIntlayer, useLocale, t } from "react-native-intlayer";
 ```
 
 ### Polyfill
@@ -50,10 +71,25 @@ import "react-native-intlayer";
 | ------------------ | ----------------------------------------------------------------------------------- |
 | `intlayerPolyfill` | Función que aplica los polyfills necesarios para que React Native soporte Intlayer. |
 
-Importación:
+```tsx
+import { intlayerPolyfill } from "react-native-intlayer";
+```
+
+> El polyfill se aplica automáticamente cuando importas `IntlayerProvider`. Llama a `intlayerPolyfill` manualmente solo si necesitas los polyfills antes de que se monte el provider.
+
+### Formateadores
+
+Los hooks de formato numérico, de fecha y otros basados en Intl están disponibles desde el subpath `/format`:
+
+```tsx
+import { useNumber, useDate } from "react-native-intlayer/format";
+```
+
+### Renderizado de Markdown y HTML
 
 ```tsx
-import "react-native-intlayer";
+import { MarkdownProvider } from "react-native-intlayer/markdown";
+import { HTMLProvider } from "react-native-intlayer/html";
 ```
 
 ### Configuración de Metro
@@ -66,8 +102,6 @@ El paquete `react-native-intlayer` proporciona utilidades de configuración de M
 | `configMetroIntlayerSync` | Función síncrona que fusiona la configuración de Metro sin preparar los recursos de Intlayer.   |
 | `exclusionList`           | Crea un patrón RegExp para el blockList de Metro para excluir archivos de contenido del bundle. |
 
-Importación:
-
 ```tsx
-import "react-native-intlayer/metro";
+import { configMetroIntlayer } from "react-native-intlayer/metro";
 ```

package/docs/es/packages/vite-intlayer/intlayerCompiler.md

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentación del plugin Vite intlayerCompiler | vite-intlayer
+description: Plugin de Vite que extrae declaraciones de contenido de Intlayer en línea de los archivos de componentes y las escribe en archivos JSON de diccionario en el momento de la compilación/transformación.
+keywords:
+  - intlayerCompiler
+  - vite
+  - plugin
+  - compilador
+  - contenido
+  - diccionario
+  - internacionalización
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Integrado en intlayer(); inicialización de doc"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+`intlayerCompiler` es un plugin de Vite que escanea los archivos de código fuente de los componentes en busca de **declaraciones de contenido inline de Intlayer** — contenido definido directamente dentro de un componente en lugar de en un archivo `.content.ts` separado — y las escribe en archivos JSON de diccionario durante la fase de transformación.
+
+> **Desde Intlayer v9**, `intlayerCompiler` se incluye automáticamente dentro del plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vite-intlayer/intlayer.md) cuando tanto `compiler.enabled` es `true` como `compiler.output` están configurados en su configuración de Intlayer. Solo necesita registrarlo por separado cuando desee tener un control total sobre la configuración específica del compilador.
+
+## Uso
+
+### Como parte de `intlayer()` (recomendado, v9+)
+
+Habilite el compilador a través de su configuración de Intlayer:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // donde se escriben los diccionarios extraídos
+  },
+});
+```
+
+Luego use el plugin estándar sin registro adicional:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Autónomo (cuando sea necesario)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Opciones
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Opción           | Tipo                      | Descripción                                                                                                             |
+| ---------------- | ------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Anulaciones de configuración de Intlayer reenviadas a `getConfiguration()`.                                             |
+| `compilerConfig` | `Partial<CompilerConfig>` | Anulaciones para la sección de configuración específica del compilador (por ejemplo, `enabled`, `output`, `filesList`). |
+
+### Ejemplo
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## Cómo funciona
+
+### Fase de transformación
+
+Para cada archivo fuente que coincida con `compiler.filesList`, el plugin del compilador:
+
+1. Pasa el contenido del archivo a través de `extractContent` de `@intlayer/babel`.
+2. Llama a `onExtract` para cada declaración encontrada, lo que escribe el JSON del diccionario resultante en `compiler.output`.
+3. Devuelve el código fuente transformado con las declaraciones en línea reemplazadas por llamadas estándar `useIntlayer('key')` / `getIntlayer('key')`.
+
+Tipos de archivos admitidos: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+Cuando se guarda un archivo de componente en modo de desarrollo, el compilador:
+
+1. Detecta el cambio de archivo a través del hook `handleHotUpdate` de Vite.
+2. Vuelve a extraer el contenido del archivo actualizado.
+3. Escribe el JSON del diccionario actualizado.
+4. Activa una recarga completa de la página (`server.ws.send({ type: 'full-reload' })`).
+
+Un retraso (debounce) de 500 ms evita que la propia escritura del diccionario (que también activa un evento de cambio de archivo) cause un bucle de re-extracción infinito.
+
+### Deduplicación
+
+`intlayerCompiler` utiliza el mismo mecanismo de deduplicación `createPrimaryInstanceGuard` que los otros plugins incluidos. Cuando están presentes tanto `intlayer()` (que incluye el compilador) como una llamada manual a `intlayerCompiler()`, solo se ejecuta la primera instancia registrada; no se escribe ningún diccionario dos veces.

package/docs/es/packages/vite-intlayer/intlayerMinify.md

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentación del plugin Vite intlayerMinify | vite-intlayer
+description: Plugin de Vite que minifica los archivos JSON de diccionarios Intlayer compilados y, opcionalmente, ofusca los nombres de los campos de contenido para reducir el tamaño del bundle.
+keywords:
+  - intlayerMinify
+  - vite
+  - plugin
+  - minificar
+  - tamaño del bundle
+  - diccionario
+  - internacionalización
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Inicialización de doc"
+author: aymericzip
+---
+
+# intlayerMinify
+
+`intlayerMinify` es un plugin de Vite que minifica archivos JSON de diccionarios compilados durante una compilación de producción. Elimina todos los espacios en blanco innecesarios y, cuando se combina con `intlayerPrune`, opcionalmente renombra los nombres de los campos de contenido a alias alfabéticos cortos (`a`, `b`, `c`, ...) para reducir aún más el tamaño del bundle.
+
+> El plugin ya está incluido y configurado automáticamente cuando utiliza [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vite-intlayer/intlayer.md). Solo necesita registrarlo manualmente si está componiendo la pila de plugins usted mismo.
+
+## Uso
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerMinify, intlayerPrune } from "vite-intlayer";
+import { createPruneContext } from "@intlayer/babel";
+
+const pruneContext = createPruneContext();
+
+export default defineConfig({
+  plugins: [
+    intlayerPrune(intlayerConfig, pruneContext),
+    intlayerMinify(intlayerConfig, pruneContext),
+  ],
+});
+```
+
+## Condiciones de activación
+
+`intlayerMinify` está activo **solo** cuando se cumplen las tres condiciones siguientes:
+
+1. El comando de Vite es `build` (no `serve` / dev).
+2. `build.optimize` es `true` (o `undefined`, que por defecto es `true` para compilaciones).
+3. `build.minify` es `true` en su configuración de Intlayer.
+
+Se **desactiva** automáticamente cuando `editor.enabled` es `true` porque el editor necesita el contenido del diccionario completo y legible por humanos.
+
+## Qué se minifica
+
+El plugin apunta a dos ubicaciones de diccionarios (según lo resuelto a partir de `intlayer.system`):
+
+- `dictionariesDir` — diccionarios estáticos para todos los idiomas (por ejemplo, `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — diccionarios dinámicos por idioma
+
+> Los diccionarios en modo fetch (`fetchDictionariesDir`) **nunca** se minifican porque se sirven desde una API remota en tiempo de ejecución utilizando sus nombres de campo originales. Cambiar el nombre de los campos crearía una discrepancia entre la respuesta del servidor y los accesos a propiedades en el lado del cliente.
+
+## Ofuscación de nombres de campo (minificación de propiedades)
+
+Cuando `intlayerPrune` ha analizado el código fuente y ha llenado `pruneContext.dictionaryKeyToFieldRenameMap`, `intlayerMinify` también cambia el nombre de los campos de contenido a alias cortos. Por ejemplo:
+
+```json
+// antes
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// después (con ofuscación)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+Los accesos a propiedades de archivos fuente correspondientes se renombran mediante el paso de Babel dentro de `intlayerOptimize`, por lo que el comportamiento en tiempo de ejecución no cambia.
+
+Los campos internos de Intlayer (`nodeType`, `translation`, etc.) nunca se renombran.
+
+## Dicionarios de casos extremos (Edge cases)
+
+Los diccionarios marcados en `pruneContext.dictionariesWithEdgeCases` (anomalías estructurales detectadas durante la fase de prune) se omiten por completo — ni se minifican ni se ofuscan — para evitar el envío de datos dañados.
+
+## Grupos calificados (colecciones / variantes / registros meta)
+
+Para diccionarios con una matriz `qualifierTypes` (colecciones, variantes y registros meta), el plugin conserva la matriz `qualifierTypes` y el mapa lateral `meta` literalmente. Solo las entradas de `content` tienen sus nombres de campo ofuscados. Las claves compuestas (utilizadas para la coincidencia de selectores en tiempo de ejecución) nunca se tocan.

package/docs/es/packages/vite-intlayer/intlayerProxy.md

@@ -0,0 +1,172 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentación del plugin Vite intlayerProxy | vite-intlayer
+description: Middleware de enrutamiento de idiomas para los servidores dev/preview de Vite y SSR de producción. Maneja la detección de idioma, redireccionamientos de URL y reescrituras internas.
+keywords:
+  - intlayerProxy
+  - vite
+  - plugin
+  - middleware
+  - idioma
+  - enrutamiento
+  - internacionalización
+  - i18n
+  - SSR
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerProxy
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Se fusionó configOptions en un solo objeto de opciones; proxy integrado en intlayer()"
+author: aymericzip
+---
+
+# intlayerProxy
+
+`intlayerProxy` es un plugin de Vite que registra un middleware de enrutamiento de idiomas para **todos los entornos**: servidor de desarrollo, servidor de vista previa y SSR de producción (Nitro / TanStack Start).
+
+> **Desde Intlayer v9**, `intlayerProxy` se incluye automáticamente dentro del plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/vite-intlayer/intlayer.md) y está habilitado por defecto mediante `routing.enableProxy: true`. Solo necesita registrarlo por separado si requiere un control de nivel inferior o si lo está utilizando fuera de la configuración estándar de `intlayer()`.
+
+## Uso
+
+### Como parte de `intlayer()` (recomendado, v9+)
+
+Pase las opciones de `proxy` al plugin principal en lugar de registrar `intlayerProxy` por separado:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
+### Autónomo (cuando sea necesario)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+## Opciones
+
+```ts
+import type { IntlayerProxyPluginOptions } from "vite-intlayer";
+```
+
+Todas las opciones son opcionales y se pasan como un único objeto:
+
+| Opción          | Tipo                                | Descripción                                                                                                                                                                |
+| --------------- | ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ignore`        | `(req: IncomingMessage) => boolean` | Predicado que excluye solicitudes del enrutamiento de idiomas. Devuelva `true` para omitir una solicitud (por ejemplo, rutas de API, controles de salud).                  |
+| `configOptions` | `GetConfigurationOptions`           | Anulaciones de configuración de Intlayer reenviadas a `getConfiguration()`. Úselo cuando necesite que el proxy lea un archivo de configuración específico o anule valores. |
+
+### Ejemplo
+
+```ts
+intlayerProxy({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+```
+
+## createIntlayerProxyHandler
+
+`createIntlayerProxyHandler` crea un middleware Node.js `(req, res, next)` independiente del framework que contiene toda la lógica de enrutamiento de idiomas. Es útil en entornos donde la API del plugin de Vite no está disponible (por ejemplo, un servidor Node.js simple o un módulo Nitro personalizado).
+
+```ts
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+const handler = createIntlayerProxyHandler({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+
+// Express / Connect
+app.use(handler);
+```
+
+### SSR de producción (TanStack Start / Nitro a través de h3)
+
+```ts
+// server/middleware/intlayerProxy.ts
+import { fromNodeMiddleware } from "h3";
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+export default fromNodeMiddleware(
+  createIntlayerProxyHandler({
+    ignore: (req) => req.url?.startsWith("/api"),
+  })
+);
+```
+
+## Comportamiento de enrutamiento
+
+El middleware refleja la lógica de enrutamiento del middleware de `next-intlayer` y es compatible con todos los modos de enrutamiento de Intlayer.
+
+### Modos de enrutamiento
+
+| Modo            | URL visible en el navegador | Comportamiento                                                                                                                          |
+| --------------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefix`        | `/es/about`                 | Por defecto. Prefijo de idioma en la URL. El idioma por defecto redirige a la URL sin prefijo a menos que `prefix-all` esté habilitado. |
+| `prefix-all`    | `/en/about`, `/es/about`    | Todos los idiomas — incluido el por defecto — siempre tienen prefijo.                                                                   |
+| `no-prefix`     | `/about`                    | Sin idioma en la URL. El idioma se almacena únicamente en las cookies; las reescrituras de URL ocurren internamente.                    |
+| `search-params` | `/about?locale=es`          | Idioma pasado como parámetro de consulta. Redirige para agregar/actualizar el parámetro `locale` cuando falta o está obsoleto.          |
+
+### Prioridad de detección
+
+1. Prefijo de ruta URL (por ejemplo, `/es/about` → `es`).
+2. Valor de cookie / localStorage (`intlayer-locale`).
+3. Cabecera `Accept-Language`.
+4. `defaultLocale` de la configuración.
+
+### Omisión automática
+
+El middleware siempre deja pasar estas solicitudes directamente sin manejo de idioma:
+
+- Solicitudes que coinciden con el predicado `ignore`.
+- `/node_modules/**`
+- `/@**` – Componentes internos de Vite (`@vite/`, `@fs/`, `@id/`, etc.).
+- `/_**` – Componentes internos del servidor (`__vite_ping`, `__manifest`, etc.).
+- Solicitudes cuya ruta termina con una extensión de archivo (activos estáticos). Si hay un prefijo de idioma presente en la ruta de un activo estático (por ejemplo, `/es/logo.png`), se elimina para que el archivo se pueda servir correctamente.
+
+### Enrutamiento de dominio
+
+Cuando `routing.domains` está configurado en su configuración de Intlayer, el middleware maneja el enrutamiento de idiomas entre dominios:
+
+- Una solicitud para `/zh/about` en `intlayer.org` se redirige a `https://intlayer.zh/about` cuando `domains.zh = "intlayer.zh"`.
+- Una solicitud a `intlayer.zh/about` se reescribe internamente a `/zh/about` para que se complete el parámetro de ruta `[locale]`.
+
+### Protección contra bucles de redirección
+
+El middleware realiza un seguimiento de los recuentos de redireccionamientos por par `originalUrl → newUrl` dentro de una ventana deslizante de 2 segundos. Más de 10 redireccionamientos dentro de esa ventana devuelven una respuesta `500` con un error descriptivo en lugar de entrar en un bucle infinito.
+
+## Nitro / SSR de producción (inyección automática, v9+)
+
+Cuando se usa `intlayerProxy` como plugin de Vite, lleva una propiedad `.nitro`. El plugin de compilación `nitro/vite` lee esta propiedad y la agrega a `nitroConfig.modules`, por lo que `intlayerNitroHandler` se registra como middleware del servidor Nitro automáticamente; no se necesita configuración manual para el SSR de producción.
+
+El controlador Nitro utiliza el modelo de eventos de la API Web Fetch de h3 v2 (no `fromNodeMiddleware`), por lo que es compatible con todos los preajustes de Nitro: Node, Bun, Deno, entornos de ejecución edge.
+
+## Alias obsoletos
+
+| Exportación obsoleta       | Reemplazo       |
+| -------------------------- | --------------- |
+| `intlayerMiddleware`       | `intlayerProxy` |
+| `intLayerMiddlewarePlugin` | `intlayerProxy` |

package/docs/es/releases/v9.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-06-14
-updatedAt: 2026-06-23
+updatedAt: 2026-06-25
 title: Nuevo Intlayer v9 - ¿Qué hay de nuevo?
 description: Descubre las novedades de Intlayer v9. Presentamos paquetes de compatibilidad directos para librerías i18n populares y soporte para Colecciones, Variantes y Registros Dinámicos.
 keywords:
@@ -248,6 +248,28 @@ Los plugins independientes `intlayerCompiler()` e `intlayerProxy()` siguen siend
 
 ---
 
+## React Native: importaciones desde un solo paquete
+
+En una aplicación de React Native o Expo, ya no necesitas alternar entre `react-intlayer` y `react-native-intlayer`. El paquete `react-native-intlayer` ahora **reexporta la API completa de `react-intlayer`** (hooks, utilidades y las subrutas `/format`, `/html`, y `/markdown`), y su `IntlayerProvider` aplica automáticamente los polyfills de React Native.
+
+Importa todo desde el paquete único `react-native-intlayer`:
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> Importar desde `react-intlayer` sigue funcionando, pero `react-native-intlayer` es ahora el punto de entrada único recomendado para React Native — su provider incluye los polyfills que el provider de `react-intlayer` (orientado a la web) no contiene.
+
+---
+
 ## Notas de migración desde v8
 
 Si estás actualizando desde v8, ten en cuenta que la v9 no incluye cambios disruptivos. Pero aquí están los cambios clave:

package/docs/fr/compiler.md

@@ -81,12 +81,15 @@ Mettez à jour votre `vite.config.ts` pour inclure le plugin `intlayerCompiler`
 
 ```ts fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/fr/custom_domains.md

@@ -172,10 +172,16 @@ Le plugin Vite `intlayerProxy` applique la même logique pendant le développeme
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/fr/custom_url_rewrites.md

@@ -342,10 +342,16 @@ Pour SolidJS, Vue et Svelte, le plugin Vite `intlayerProxy` gère les réécritu
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/fr/intlayer_with_analog.md

@@ -207,7 +207,11 @@ import analog from "@analogjs/platform";
 export default defineConfig(() => ({
   plugins: [
     analog(),
-    intlayer(), // Ajouter le plugin Intlayer
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 }));
 ```

package/docs/fr/intlayer_with_astro.md

@@ -517,6 +517,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -526,7 +528,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_astro_lit.md

@@ -601,6 +601,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -610,7 +612,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_astro_preact.md

@@ -556,6 +556,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -565,7 +567,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```