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

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

package/docs/es/releases/v9.md

@@ -0,0 +1,312 @@
+---
+createdAt: 2026-06-14
+updatedAt: 2026-06-26
+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 y Variantes.
+keywords:
+  - Intlayer
+  - Compatibility
+  - Migration
+  - Collections
+  - Variants
+  - i18next
+  - next-intl
+  - vue-i18n
+slugs:
+  - doc
+  - releases
+  - v9
+author: aymericzip
+---
+
+# Nuevo Intlayer v9 - ¿Qué hay de nuevo?
+
+¡Bienvenido a Intlayer v9! Esta importante versión marca un gran hito al simplificar la ruta de migración a Intlayer con **Paquetes Adaptadores de Compatibilidad** para las principales librerías i18n (`react-i18next`, `next-intl`, `vue-i18n`, etc.) y añade soporte para estructuras de contenido enriquecido: **Colecciones** y **Variantes**.
+
+## Tabla de contenidos
+
+<TOC levels={[2]} maxDepth={1} />
+
+---
+
+## Paquetes Adaptadores de Compatibilidad
+
+Migrar a Intlayer desde librerías i18n populares es ahora más fácil que nunca. Hemos creado cinco paquetes de compatibilidad que exponen las **mismas APIs públicas exactas** que las librerías i18n estándar, pero delegan todo el trabajo de traducción a Intlayer en tiempo de ejecución.
+
+### Exponer la Misma API Pública con Tipado Estricto
+
+Al reemplazar los imports, obtienes todos los beneficios de Intlayer (incluida la seguridad de tipos en tiempo de compilación contra tus diccionarios reales) con cambios mínimos en el código:
+
+- `@intlayer/i18next`
+- `@intlayer/react-i18next`
+- `@intlayer/next-intl`
+- `@intlayer/react-intl`
+- `@intlayer/next-i18next`
+- `@intlayer/vue-i18n`
+- `@intlayer/lingui`
+
+Por ejemplo, simplemente cambia:
+
+```ts
+import { useTranslation } from "react-i18next";
+```
+
+a:
+
+```ts
+import { useTranslation } from "@intlayer/react-i18next";
+```
+
+¡Tus claves ahora estarán **estrictamente tipadas** contra tus diccionarios de Intlayer, ofreciendo auto-completado completo de rutas con puntos en tu IDE!
+
+### Plugins de Alias de Bundler (Vite, Next.js, Turbopack)
+
+Para permitir la migración sin reescribir manualmente todas tus declaraciones de importación, cada paquete adaptador de compatibilidad incluye un **plugin de bundler personalizado** (Vite o Next.js) bajo la subruta `/plugin`.
+
+Estos plugins reescriben automáticamente los imports existentes (por ejemplo, `react-i18next` o `next-intl`) a sus equivalentes `@intlayer/*` en tiempo de compilación.
+
+#### Ejemplo de Next.js (Webpack / Turbopack)
+
+En lugar de `withIntlayer`, envuelve tu configuración de Next.js con el plugin de compatibilidad:
+
+```ts fileName="next.config.ts"
+import { createNextI18nPlugin } from "@intlayer/next-i18next/plugin";
+import type { NextConfig } from "next";
+
+const withIntlayer = createNextI18nPlugin();
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+#### Ejemplo de Vite (React, Vue, Solid, Svelte)
+
+```ts fileName="vite.config.ts"
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vueI18nVitePlugin()],
+});
+```
+
+---
+
+## Resolvedor de Tiempo de Ejecución Mutualizado
+
+Todos los adaptadores de compatibilidad ahora enrutan la resolución de traducciones a través de un único parser de tiempo de ejecución altamente optimizado: `@intlayer/core/messageFormat`.
+
+- **Interpolación de Mensajes**: Resuelve `{{var}}` estándar (espacios en blanco y rutas con puntos), argumentos formateados ICU (`{v, number, percent}` etc.) y plantillas `{var}` simples.
+- **Resolvedor de Nodos de Mensaje**: Resuelve nodos anidados: `insert()`, `plural()` (reglas de plural CLDR), `enu()` (enumeración), `gender()`, etiquetas HTML, arrays y nodos de función invocables.
+- **Parser de Etiquetas Tokenizadas**: Soporta etiquetas XML/HTML en línea y etiquetas numeradas (por ejemplo, `<1>children</1>`) para potenciar la renderización de texto enriquecido de forma predeterminada.
+
+---
+
+## Especificación de Características: Colecciones y Variantes
+
+Intlayer v9 se expande más allá de los objetos estáticos clave-valor, permitiendo que los diccionarios declaren estructuras de diseño dinámicas que están completamente tipadas de principio a fin.
+
+### 1. Colecciones
+
+Define una lista de elementos ordenados gestionada por CMS (por ejemplo, FAQs, productos o listas de blogs):
+
+```ts fileName="faq.1.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 1,
+  content: {
+    question: t({ en: "What is Intlayer?", fr: "Qu'est-ce qu'Intlayer ?" }),
+    answer: t({ en: "An i18n toolkit.", fr: "Une boîte à outils i18n." }),
+  },
+} satisfies Dictionary;
+```
+
+```ts fileName="faq.2.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 2,
+  content: {
+    question: t({ en: "Is it free?", fr: "Est-ce gratuit ?" }),
+    answer: t({ en: "Yes, open-source.", fr: "Oui, open-source." }),
+  },
+} satisfies Dictionary;
+```
+
+#### Uso:
+
+```ts
+// Fetch all items as an array
+const allFaqs = useIntlayer("faq"); // -> { question: string, answer: string }[]
+
+// Fetch a single item by index
+const faq = useIntlayer("faq", { item: 2 }); // -> { question: string, answer: string }
+```
+
+### 2. Variantes
+
+Ofrece pruebas A/B, encabezados de temporada, feature flags o landing pages personalizadas:
+
+#### Variantes de cadena (por ejemplo, pruebas A/B)
+
+```ts fileName="hero.content.ts"
+import { t, type Dictionary } => "intlayer";
+
+export default {
+  key: "hero-banner",
+  variant: "default",
+  content: {
+    control: t({ es: "Bienvenido", en: "Welcome", fr: "Bienvenue" }),
+    black_friday: t({ es: "Comprar ahora", en: "Shop now", fr: "Acheter maintenant" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Uso:
+
+```ts
+const banner = useIntlayer("hero-banner", { variant: "black_friday" });
+```
+
+#### Variantes de objeto (por ejemplo, Dynamic Records)
+
+```ts fileName="product.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "product-copy",
+  variant: {
+    id: "prod_123",
+    category: "books",
+  },
+  content: {
+    title: t({ es: "Código Limpio", en: "Clean Code", fr: "Code Propre" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Uso:
+
+```ts
+// Fetches only the requested item dynamically (requires Suspense)
+const product = useIntlayer("product-copy", {
+  variant: { id: "prod_123", category: "books" },
+});
+```
+
+---
+
+## Carga Dinámica y Optimizaciones del Tamaño del Bundle
+
+Para mantener los bundles extremadamente pequeños, Intlayer v9 soporta la carga perezosa dinámica.
+
+En tu configuración, establece `importMode` a `'dynamic'` o `'fetch'`::
+
+```ts fileName="intlayer.config.ts"
+export default {
+  dictionary: {
+    importMode: "dynamic", // "static" | "dynamic" | "fetch"
+  },
+};
+```
+
+En tiempo de compilación, `@intlayer/swc` y `@intlayer/babel` escanean tus archivos y reemplazan las llamadas a `useIntlayer` / `getIntlayer` con wrappers tree-shakeable (`useDictionary` / `useDictionaryDynamic`). Solo se carga el contenido requerido para el elemento de colección, variante o locale seleccionado, evitando que tu bundle de producción contenga traducciones no utilizadas.
+
+---
+
+## Plugin de Vite: Compilador Integrado y Proxy
+
+El plugin de Vite `intlayer()` ahora integra el **compilador** y el **proxy de enrutamiento de locales** directamente, por lo que la mayoría de proyectos solo necesitan un único plugin en `vite.config.ts`:
+
+```ts fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+- **Compilador**: Se activa automáticamente cuando `compiler.enabled` está configurado en `true` y se define una ruta `compiler.output`. Ya no necesitas registrar `intlayerCompiler()` por separado.
+- **Proxy**: Se activa automáticamente basado en la nueva opción `routing.enableProxy` (`true` por defecto). Conecta el middleware de detección de locales / redirección / reescritura en desarrollo, vista previa y SSR de producción. Ya no necesitas registrar `intlayerProxy()` por separado.
+
+### Opción `routing.enableProxy`
+
+Una nueva opción `routing.enableProxy` controla si el proxy de enrutamiento de locales está activado. Por defecto es `true`. Desactívalo cuando quieras manejar el enrutamiento de locales por tu cuenta:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  routing: {
+    enableProxy: false, // Por defecto: true
+  },
+};
+
+export default config;
+```
+
+Los plugins independientes `intlayerCompiler()` e `intlayerProxy()` siguen siendo exportados para configuraciones avanzadas. Registrarlos junto con `intlayer()` es seguro — cada plugin se deduplica a sí mismo y se ejecuta solo una vez.
+
+---
+
+## Compilador deshabilitado por defecto
+
+A partir de Intlayer v9, el **compilador está deshabilitado por defecto** (`compiler.enabled` ahora tiene el valor predeterminado `false`). Para habilitar la extracción de tus archivos `.content.ts` en tiempo de compilación, establece `compiler.enabled: true` en tu configuración:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Por defecto: false — requerido para habilitar el compilador desde la v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Cuando el compilador está deshabilitado, Intlayer omite el paso de extracción en tiempo de compilación y se basa en tus diccionarios ya declarados. Habilítalo solo cuando quieras que el plugin del bundler (`@intlayer/swc`, `@intlayer/babel` o el plugin de Vite `intlayer()`) extraiga el contenido automáticamente.
+
+---
+
+## 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:
+
+- **Compilador deshabilitado por defecto**: `compiler.enabled` ahora tiene el valor predeterminado `false`. Si dependes de la extracción de tus archivos `.content.ts` en tiempo de compilación, establece `compiler.enabled: true` en tu `intlayer.config.ts`.
+- **Locales y Dialectos**: Si utilizas dependencias i18n externas, añade sus respectivos plugins adaptadores de compatibilidad en tu configuración o setup del bundler para reescribir automáticamente los imports.
+- **Selectores Personalizados**: Al llamar a `useIntlayer`, el segundo parámetro ahora está reservado para un objeto de opciones que contiene `{ locale, item, variant }`. Si anteriormente pasabas una cadena de locale directamente, aún puedes hacerlo, pero se recomienda usar el objeto de opciones para selecciones avanzadas.
+
+---
+
+## Enlaces útiles
+
+- [Guía de Paquetes Adaptadores de Compatibilidad](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/compat/index.md)
+- [Diccionarios Dinámicos - Colecciones y Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dynamic_dictionaries/index.md)
+- [Referencia de Configuración](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/configuration.md)

package/docs/es/roadmap.md

@@ -29,6 +29,12 @@ Intlayer es una solución de gestión de contenido e internacionalización dise
 
 ---
 
+## Tabla de contenidos
+
+<TOC/>
+
+---
+
 ## Funcionalidades Actuales
 
 ### 1. Declaración de Contenido

package/docs/fr/CI_CD.md

@@ -26,6 +26,10 @@ author: aymericzip
 
 Intlayer permet la génération automatique des traductions pour vos fichiers de déclaration de contenu. Plusieurs méthodes existent selon votre flux de travail.
 
+## Table des matières
+
+<TOC/>
+
 ## Utilisation du CMS
 
 Avec Intlayer, vous pouvez adopter un flux de travail où une seule locale est déclarée localement, tandis que toutes les traductions sont gérées à distance via le CMS. Cela permet de détacher complètement le contenu et les traductions de la base de code, offrant plus de flexibilité aux éditeurs de contenu et permettant le rechargement dynamique du contenu (pas besoin de reconstruire l'application pour appliquer les modifications).

package/docs/fr/autoFill.md

@@ -28,6 +28,53 @@ history:
 author: aymericzip
 ---
 
+# Remplir les fichiers de déclaration de contenu traduits
+
+**L'autofill des fichiers de déclaration de contenu** dans votre CI est un moyen d'accélérer votre flux de développement.
+
+## Comprendre le comportement
+
+La commande `fill` inclut deux modes :
+
+- **Complete** : Remplit automatiquement tout le contenu manquant pour chaque locale et modifie le fichier actuel, ou un autre fichier s'il est spécifié. C'est-à-dire que le mode complete ignorera la traduction du contenu existant, s'il est déjà traduit.
+- **Review** : Remplit automatiquement **tout** le contenu pour chaque locale et génère pour un fichier spécifique, ou un autre fichier s'il est spécifié.
+
+La commande will traitera tous vos fichiers de déclaration de contenu locale. C'est-à-dire qu'elle ne traitera pas votre contenu distant du CMS. Le CMS inclut sa propre gestion des traductions.
+Si vous utilisez des plugins comme `@intlayer/sync-json-plugin`, Intlayer transformera les fichiers JSON en fichiers de déclaration de contenu locale. C'est-à-dire qu'ils seront traités par la commande `fill`.
+
+Les fichiers nouvellement générés incluent une instruction `filled` comme métadonnées de dictionnaire. Cette instruction sera utilisée par Intlayer pour savoir si le fichier a été rempli automatiquement ou non, et ignorer ce fichier d'une traduction supplémentaire s'il est présent.
+
+Intlayer considérera également l'instruction suivante pour le remplissage automatique :
+
+- De votre `.content.{ts|js|json}` → instruction `fill`
+- De votre fichier de configuration `.intlayer.config.ts` → instruction `dictionary.fill`
+- Sera défini à `true` par défaut autrement
+
+Pour les fichiers de déclaration de contenu par locale, l'instruction `true` sera remplacée par `./{{fileName}}.fill.content.json`. C'est parce qu'un fichier de déclaration de contenu par locale ne peut pas recevoir de contenu localisé supplémentaire. Donc il générera un nouveau fichier pour ne pas écraser le fichier existant.
+
+## Comportement par défaut
+
+Par défaut, `fill` est défini sur `true` globalement, ce qui signifie qu'Intlayer remplira automatiquement tous les fichiers de contenu et modifiera le fichier lui-même. Ce comportement peut être personnalisé de plusieurs façons :
+
+### Options de Configuration Globale
+
+1. **`fill: true` (par défaut)** - Remplir automatiquement toutes les locales et éditer le fichier courant
+2. **`fill: false`** - Désactiver le remplissage automatique pour ce fichier de contenu
+3. **`fill: "./relative/path/to/file"`** - Créer/mettre à jour le fichier spécifié sans éditer le fichier courant en pointant vers un chemin relatif résolu en fonction de l'emplacement du fichier courant
+4. **`fill: "/absolute/path/to/file"`** - Créer/mettre à jour le fichier spécifié sans éditer le fichier courant en pointant vers un chemin relatif résolu en fonction de l'emplacement du répertoire de base (champ `baseDir` dans le fichier de configuration `.intlayer.config.ts`)
+5. **`fill: "C:\\absolute\path\to\file"`** - Créer/mettre à jour le fichier spécifié sans éditer le fichier courant en pointant vers un chemin absolu résolu en fonction de votre système d'exploitation
+6. **`fill: { [key in Locales]?: string }`** - Créer/mettre à jour le fichier spécifié pour chaque locale
+
+### Changements de comportement v7
+
+Dans v7, le comportement de la commande `fill` a été mis à jour :
+
+- **`fill: true`** - Réécrit le fichier courant avec le contenu rempli pour toutes les locales
+- **`fill: "path/to/file"`** - Remplit le fichier spécifié sans modifier le fichier courant
+- **`fill: false`** - Désactive complètement le remplissage automatique
+
+Lors de l'utilisation d'une option de chemin pour écrire dans un autre fichier, le mécanisme de remplissage fonctionne via une relation _maître-esclave_ entre les fichiers de déclaration de contenu. Le fichier principal (maître) sert de source de vérité, et lorsqu'il est mis à jour, Intlayer applique automatiquement ces modifications aux fichiers de déclaration dérivés (remplis) spécifiés par le chemin.
+
 # Traductions des fichiers de déclaration de contenu avec remplissage automatique
 
 **Les fichiers de déclaration de contenu avec remplissage automatique** sont un moyen d'accélérer votre flux de travail de développement.
@@ -88,6 +135,40 @@ Intlayer générera automatiquement le fichier de déclaration dérivé à `src/
 
 Ensuite, les deux fichiers de déclaration seront fusionnés en un seul dictionnaire, accessible via le hook standard `useIntlayer("example")` (react) / composable (vue).
 
+## Configuration globale
+
+Vous pouvez configurer la configuration de remplissage automatique globale dans le fichier `intlayer.config.ts`.
+
+```ts fileName="intlayer.config.ts"
+import { type IntlayerConfig, Locales } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+    requiredLocales: [Locales.ENGLISH, Locales.FRENCH],
+  },
+  dictionary: {
+    // Générer automatiquement les traductions manquantes pour tous les dictionnaires
+    fill: "./{{fileName}}Filled.content.ts",
+    //
+    // fill: "/messages/{{locale}}/{{key}}/{{fileName}}.content.json",
+    //
+    // fill: true, // générer automatiquement les traductions manquantes pour tous les dictionnaires comme en utilisant "./{{fileName}}.content.json"
+    //
+    // fill: {
+    //   en: "./{{fileName}}.en.content.json",
+    //   fr: "./{{fileName}}.fr.content.json",
+    //   es: "./{{fileName}}.es.content.json",
+    // },
+  },
+};
+
+export default config;
+```
+
+Vous pouvez toujours affiner par dictionnaire en utilisant le champ `fill` dans les fichiers de contenu. Intlayer considérera d'abord la configuration par dictionnaire et reviendra ensuite à la configuration globale.
+
 ## Format du fichier rempli automatiquement
 
 Le format recommandé pour les fichiers de déclaration remplis automatiquement est **JSON**, ce qui permet d'éviter les contraintes de formatage. Cependant, Intlayer prend également en charge les formats `.ts`, `.js`, `.mjs`, `.cjs` et d'autres.