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

package/docs/fr/releases/v8.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-22
-updatedAt: 2026-01-26
+updatedAt: 2026-06-14
 title: Nouveau Intlayer v8 - Quoi de neuf ?
 description: Découvrez les nouveautés d'Intlayer v8. Améliorations majeures de l'expérience développeur, de la validation du contenu et de la gestion des dictionnaires.
 keywords:
@@ -409,6 +409,16 @@ Pour plus de détails, consultez la [Documentation sur le Contenu HTML](https://
 
 ---
 
+## Fichiers de Contenu YAML & Markdown (v8.10.0)
+
+Vous pouvez désormais déclarer du contenu directement en utilisant les extensions de fichier `.content.md` et `.content.yaml`. C'est parfait pour les contenus longs, les blogs, la documentation et les politiques de confidentialité.
+
+Ces fichiers sont entièrement modifiables depuis l'Éditeur Visuel, offrant un flux de travail simplifié pour les membres non techniques de l'équipe.
+
+Pour plus de détails, consultez la [Documentation des Fichiers de Contenu YAML](https://intlayer.org/fr/doc/concept/content#yaml-content-file) et la [Documentation des Fichiers de Contenu Markdown](https://intlayer.org/fr/doc/concept/content/markdown).
+
+---
+
 ## Réécritures d'URL Personnalisées
 
 Intlayer v8 introduit la prise en charge des **réécritures d'URL personnalisées**, vous permettant de définir des chemins spécifiques à la langue qui diffèrent de la structure standard `/locale/path`. C'est une fonctionnalité puissante pour améliorer le SEO local et offrir une expérience utilisateur plus naturelle aux non-anglophones.
@@ -753,6 +763,58 @@ export default {
   </Tab>
 </Tabs>
 
+## Règles de Pluriels Unicode CLDR (v8.8.0)
+
+Un nouvel assistant de nœud `plural` a été introduit, basé sur les règles de pluriel définies par le projet Unicode CLDR, améliorant le support des langues complexes.
+
+```typescript fileName="src/openings.content.ts"
+import { plural, t, type Dictionary } from "intlayer";
+
+const openingsContent = {
+  key: "total_openings",
+  content: {
+    totalOpenings: t({
+      fr: plural({
+        one: "{{count}} offre",
+        other: "{{count}} offres",
+      }),
+      en: plural({
+        one: "{{count}} opening",
+        other: "{{count}} openings",
+      }),
+    }),
+  },
+} satisfies Dictionary;
+
+export default openingsContent;
+```
+
+Vous pouvez ensuite passer le nombre dynamiquement dans votre composant de 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 anglais :                                 */}
+      {/*  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>
+  );
+};
+```
+
+Pour plus d'informations, consultez la [Documentation sur la Pluralisation](https://intlayer.org/fr/doc/concept/content/plural).
+
+---
+
 ## Validation du Schéma de Contenu
 
 Intlayer v8 introduit la validation de schéma pour les dictionnaires. Vous pouvez désormais définir des schémas de validation réutilisables dans votre configuration à l'aide de Zod et les appliquer à vos fichiers de contenu. Cela garantit que votre contenu respecte toujours la structure attendue, capturant les erreurs au moment de la construction.
@@ -797,6 +859,34 @@ Si le contenu ne correspond pas au schéma (par exemple, le titre est trop court
 
 ---
 
+## TypeScript : Accesseurs Primitifs IntlayerNode
+
+Le type `IntlayerNode` a été mis à jour pour permettre l'appel de méthodes JavaScript primitives directement sur les nœuds de contenu. Cela permet d'interagir avec votre contenu localisé directement comme s'il s'agissait d'une primitive standard de type chaîne, nombre, booléen ou tableau.
+
+Pris en charge sur React, Preact, Solid, Svelte, Vue et Angular.
+
+### Exemple de Chaîne de Caractères
+
+```typescript
+content.placeholder; // Retourne IntlayerNode<string>
+content.placeholder.value; // Retourne string
+content.placeholder.toString(); // Retourne string
+content.placeholder.toLowerCase(); // Retourne string
+String(content.placeholder); // Retourne string
+content.placeholder.toUpperCase(); // Retourne la chaîne en majuscules
+content.placeholder.replace("a", "b"); // Retourne la chaîne modifiée
+```
+
+### Exemple de Tableau
+
+```typescript
+content.myArrayOfString             // Retourne IntlayerNode<Array<string>>
+content.myArrayOfString.find(...)   // Retourne l'élément
+content.myArrayOfString.join(', ')  // Retourne la chaîne jointe
+```
+
+---
+
 ### Détection Automatique du Contenu Améliorée
 
 En v8, Intlayer détecte intelligemment la syntaxe Markdown, les balises HTML et les insertions de variables dans vos chaînes de contenu. Cela signifie que vous pouvez souvent omettre les fonctions d'aide comme `md()`, `html()`, ou `insert()`.
@@ -1002,6 +1092,17 @@ L'extension VSCode d'Intlayer reçoit des mises à jour majeures en v8 pour rati
 
 ---
 
+## Outils : Watcher C++ & LSP basé sur OXC (v8.12.0)
+
+Intlayer v8.12.0 apporte des améliorations majeures à l'expérience développeur :
+
+- **Parcel Watcher** : Le watcher de contenu a été migré de `chokidar` vers `@parcel/watcher`, exploitant la surveillance de fichiers native en C++ pour fournir des mises à jour plus rapides et une consommation de mémoire considérablement réduite.
+- **Nouveau Language Server Protocol (LSP)** : Un tout nouveau LSP est désormais disponible. Conçu avec une analyse basée sur OXC, il aide votre IDE et vos agents IA à lier de manière transparente les appels `useIntlayer('my-key')` à leurs fichiers `.content` correspondants, et vice versa.
+
+Pour plus de détails, consultez la [Documentation LSP](https://intlayer.org/fr/doc/lsp).
+
+---
+
 ## Optimisations du Compilateur
 
 Intlayer v8 inclut une nouvelle couche de mise en cache pour le compilateur Markdown et HTML. Cela garantit que les chaînes de contenu identiques avec la même configuration ne sont analysées qu'une seule fois, réduisant considérablement la surcharge lors des re-rendus ou lors de l'utilisation du même contenu à plusieurs endroits.
@@ -1057,6 +1158,48 @@ Intlayer v8 inclut une nouvelle couche de mise en cache pour le compilateur Mark
 
 ---
 
+## Optimisations de Build Expérimentales : Minify & Purge (v8.7.0)
+
+Intlayer v8.7.0 introduit de nouvelles fonctionnalités de build expérimentales dans votre `intlayer.config.ts` conçues pour optimiser votre bundle de production :
+
+- **Minification des Dictionnaires** : Minifie les fichiers de dictionnaire pour réduire leur taille.
+- **Purge des Clés Inutilisées** : Analyse et supprime les clés de traduction inutilisées des dictionnaires, en renommant les clés actives avec des caractères courts (par exemple, `"products" -> "a"`, `"pricing" -> "b"`). Cela réduit la taille du bundle jusqu'à 5 %.
+- **Désactivation des Vérifications TypeScript** : Accélère les builds en désactivant la vérification des types TypeScript pendant l'étape de compilation.
+
+```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: {
+    /**
+     * Minifier les dictionnaires pour réduire la taille du bundle.
+     */
+    minify: true,
+
+    /**
+     * Purger les clés inutilisées dans les dictionnaires.
+     */
+    purge: true,
+
+    /**
+     * Indique si le build doit vérifier les types TypeScript.
+     */
+    checkTypes: false,
+  },
+};
+
+export default config;
+```
+
+---
+
 ## Flexibilité : Mode d'Importation Unifié
 
 La propriété booléenne `live` a été dépréciée au profit d'une propriété `importMode` plus complète. Cela permet une définition explicite de la manière dont les dictionnaires doivent être chargés : statiquement, dynamiquement ou via la synchronisation en direct.
@@ -1204,6 +1347,49 @@ Le contenu Markdown et HTML dans Svelte s'analyse désormais automatiquement en
 
 ---
 
+## Support Angular : Bundler Vite (v8.11.0)
+
+Pour les utilisateurs d'Angular, Intlayer prend désormais en charge nativement le bundler Vite via un nouveau plugin esbuild personnalisé, accélérant les temps de développement et de build.
+
+Pour plus de détails sur la configuration, consultez la [Documentation de l'Environnement Angular](https://intlayer.org/fr/doc/environment/angular).
+
+---
+
+## Génération de Sitemap (v8.6.0)
+
+Intlayer génère désormais automatiquement des sitemaps en fonction de vos locales et de votre mode de routage. C'est particulièrement utile pour l'optimisation SEO dans les architectures de routeurs comme 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" },
+        });
+      },
+    },
+  },
+});
+```
+
+---
+
 ## Notes de migration depuis la v7
 
 ### Changements de Configuration

package/docs/fr/releases/v9.md

@@ -0,0 +1,312 @@
+---
+createdAt: 2026-06-14
+updatedAt: 2026-06-26
+title: Nouvel Intlayer v9 - Quoi de neuf ?
+description: Découvrez les nouveautés d'Intlayer v9. Présentation des packages de compatibilité prêts à l'emploi pour les bibliothèques i18n populaires et prise en charge des Collections et Variants.
+keywords:
+  - Intlayer
+  - Compatibility
+  - Migration
+  - Collections
+  - Variants
+  - i18next
+  - next-intl
+  - vue-i18n
+slugs:
+  - doc
+  - releases
+  - v9
+author: aymericzip
+---
+
+# Nouvel Intlayer v9 - Quoi de neuf ?
+
+Bienvenue sur Intlayer v9 ! Cette version majeure marque une étape importante dans la simplification du chemin de migration vers Intlayer avec les **packages d'adaptateurs de compatibilité** pour les principales bibliothèques i18n (`react-i18next`, `next-intl`, `vue-i18n`, etc.) et ajoute la prise en charge de structures de contenu riches : les **Collections** et les **Variants**.
+
+## Table des matières
+
+<TOC levels={[2]} maxDepth={1} />
+
+---
+
+## Packages d'adaptateurs de compatibilité
+
+La migration vers Intlayer depuis les bibliothèques i18n populaires est désormais plus facile que jamais. Nous avons créé cinq packages de compatibilité qui exposent les **mêmes API publiques exactes** que les bibliothèques i18n standard, mais délèguent tout le travail de traduction à Intlayer au moment de l'exécution.
+
+### Exposer la même API publique avec un typage strict
+
+En remplaçant les imports, vous bénéficiez de tous les avantages d'Intlayer (y compris la sécurité de type au moment de la compilation par rapport à vos dictionnaires réels) avec des modifications de code minimales :
+
+- `@intlayer/i18next`
+- `@intlayer/react-i18next`
+- `@intlayer/next-intl`
+- `@intlayer/react-intl`
+- `@intlayer/next-i18next`
+- `@intlayer/vue-i18n`
+- `@intlayer/lingui`
+
+Par exemple, changez simplement :
+
+```ts
+import { useTranslation } from "react-i18next";
+```
+
+en :
+
+```ts
+import { useTranslation } from "@intlayer/react-i18next";
+```
+
+Vos clés seront désormais **strictement typées** par rapport à vos dictionnaires Intlayer, offrant une auto-complétion complète des chemins par points dans votre IDE !
+
+### Plugins d'alias de Bundler (Vite, Next.js, Turbopack)
+
+Pour permettre la migration sans réécrire manuellement toutes vos déclarations d'import, chaque package d'adaptateur de compatibilité inclut un **plugin de bundler personnalisé** (Vite ou Next.js) sous le sous-chemin `/plugin`.
+
+Ces plugins réécrivent automatiquement les imports existants (par exemple `react-i18next` ou `next-intl`) vers leurs équivalents `@intlayer/*` au moment de la compilation.
+
+#### Exemple Next.js (Webpack / Turbopack)
+
+Au lieu de `withIntlayer`, enveloppez votre configuration Next.js avec le plugin de compatibilité :
+
+```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);
+```
+
+#### Exemple Vite (React, Vue, Solid, Svelte)
+
+```ts fileName="vite.config.ts"
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vueI18nVitePlugin()],
+});
+```
+
+---
+
+## Résolveur d'exécution mutualisé
+
+Tous les adaptateurs de compatibilité acheminent désormais la résolution des traductions via un seul analyseur d'exécution hautement optimisé : `@intlayer/core/messageFormat`.
+
+- **Interpoler le message** : Résout les `{{var}}` standard (espaces et chemins par points), les arguments formatés ICU (`{v, number, percent}` etc.) et les templates `{var}` bruts.
+- **Résolveur de nœuds de message** : Résout les nœuds imbriqués : `insert()`, `plural()` (règles de pluriel CLDR), `enu()` (énumération), `gender()`, les balises HTML, les tableaux et les nœuds de fonction appelables.
+- **Analyseur de balises tokenisées** : Prend en charge les balises XML/HTML en ligne et les balises numérotées (par exemple, `<1>children</1>`) pour permettre le rendu de texte riche dès la première utilisation.
+
+---
+
+## Spécification des fonctionnalités : Collections & Variants
+
+Intlayer v9 va au-delà des objets clé-valeur statiques, permettant aux dictionnaires de déclarer des structures de mise en page dynamiques entièrement typées de bout en bout.
+
+### 1. Collections
+
+Définissez une liste d'éléments ordonnés gérée par un CMS (par exemple, FAQ, produits ou listes 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;
+```
+
+#### Utilisation :
+
+```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. Variants
+
+Proposez des tests A/B, des en-têtes saisonniers, des feature flags ou des pages de destination personnalisées :
+
+#### Variantes de chaîne (ex. tests A/B)
+
+```ts fileName="hero.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "hero-banner",
+  variant: "default",
+  content: {
+    control: t({ fr: "Bienvenue", en: "Welcome" }),
+    black_friday: t({ fr: "Acheter maintenant", en: "Shop now" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Utilisation :
+
+```ts
+const banner = useIntlayer("hero-banner", { variant: "black_friday" });
+```
+
+#### Variantes d'objet (ex. 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({ fr: "Code Propre", en: "Clean Code" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Utilisation :
+
+```ts
+// Récupère uniquement l'élément demandé dynamiquement (nécessite Suspense)
+const product = useIntlayer("product-copy", {
+  variant: { id: "prod_123", category: "books" },
+});
+```
+
+---
+
+## Chargement dynamique et optimisations de la taille du bundle
+
+Pour maintenir les bundles extrêmement petits, Intlayer v9 prend en charge le chargement paresseux dynamique.
+
+Dans votre configuration, définissez `importMode` sur `'dynamic'` ou `'fetch'` :
+
+```ts fileName="intlayer.config.ts"
+export default {
+  dictionary: {
+    importMode: "dynamic", // "static" | "dynamic" | "fetch"
+  },
+};
+```
+
+Au moment de la compilation, `@intlayer/swc` et `@intlayer/babel` analysent vos fichiers et remplacent les appels `useIntlayer` / `getIntlayer` par des wrappers optimisés par tree-shaking (`useDictionary` / `useDictionaryDynamic`). Seul le contenu requis pour l'élément de collection, le variant ou la locale sélectionné est chargé, empêchant ainsi votre bundle de production de contenir des traductions inutilisées.
+
+---
+
+## Plugin Vite : Compilateur Bundled & Proxy
+
+Le plugin Vite `intlayer()` regroupe maintenant le **compilateur** et le **proxy de routage de locale** directement, donc la plupart des projets n'ont besoin que d'un seul plugin dans `vite.config.ts` :
+
+```ts fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+- **Compilateur** : S'active automatiquement lorsque `compiler.enabled` est défini à `true` et qu'un chemin `compiler.output` est configuré. Vous n'avez plus besoin d'enregistrer `intlayerCompiler()` séparément.
+- **Proxy** : S'active automatiquement en fonction de la nouvelle option `routing.enableProxy` (`true` par défaut). Il connecte le middleware de détection de locale / redirection / réécriture en développement, en aperçu et en SSR de production. Vous n'avez plus besoin d'enregistrer `intlayerProxy()` séparément.
+
+### Option `routing.enableProxy`
+
+Une nouvelle option `routing.enableProxy` contrôle si le proxy de routage des locales est activé. Par défaut, elle est définie à `true`. Désactivez-la si vous souhaitez gérer le routage des locales vous-même :
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  routing: {
+    enableProxy: false, // Par défaut: true
+  },
+};
+
+export default config;
+```
+
+Les plugins autonomes `intlayerCompiler()` et `intlayerProxy()` restent exportés pour les configurations avancées. Les enregistrer aux côtés de `intlayer()` est sûr — chaque plugin se déduplique et s'exécute une seule fois.
+
+---
+
+## Compilateur désactivé par défaut
+
+Depuis Intlayer v9, le **compilateur est désactivé par défaut** (`compiler.enabled` vaut désormais `false` par défaut). Pour activer l'extraction de vos fichiers `.content.ts` au moment du build, définissez `compiler.enabled: true` dans votre configuration :
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Par défaut : false — requis pour activer le compilateur depuis la v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Lorsque le compilateur est désactivé, Intlayer ignore l'étape d'extraction au build et s'appuie sur vos dictionnaires déjà déclarés. Activez-le uniquement lorsque vous souhaitez que le plugin de bundler (`@intlayer/swc`, `@intlayer/babel`, ou le plugin Vite `intlayer()`) extraie le contenu automatiquement.
+
+---
+
+## React Native : imports depuis un seul package
+
+Dans une application React Native ou Expo, vous n'avez plus besoin de jongler entre `react-intlayer` et `react-native-intlayer`. Le package `react-native-intlayer` **réexporte désormais l'intégralité de l'API `react-intlayer`** (hooks, utilitaires et les sous-chemins `/format`, `/html`, et `/markdown`), et son `IntlayerProvider` applique automatiquement les polyfills React Native.
+
+Importez tout depuis le package unique `react-native-intlayer` :
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> L'importation depuis `react-intlayer` continue de fonctionner, mais `react-native-intlayer` est désormais le point d'entrée unique recommandé pour React Native — son provider inclut les polyfills que le provider `react-intlayer` (orienté web) ne contient pas.
+
+---
+
+## Notes de migration depuis la v8
+
+Si vous effectuez une mise à niveau depuis la v8, notez que la v9 n'inclut pas de changements majeurs (breaking changes). Voici cependant les changements clés :
+
+- **Compilateur désactivé par défaut** : `compiler.enabled` vaut désormais `false` par défaut. Si vous dépendez de l'extraction de vos fichiers `.content.ts` au build, définissez `compiler.enabled: true` dans votre `intlayer.config.ts`.
+- **Locales et dialectes** : Si vous utilisez des dépendances i18n externes, ajoutez leurs plugins d'adaptateur de compatibilité respectifs dans votre configuration ou votre setup de bundler pour réécrire automatiquement les imports.
+- **Sélecteurs personnalisés** : Lors de l'appel de `useIntlayer`, le deuxième paramètre est désormais réservé à un objet d'options contenant `{ locale, item, variant }`. Si vous passiez auparavant une chaîne de caractères de locale directement, vous pouvez toujours le faire, mais l'utilisation de l'objet d'options est recommandée pour les sélections avancées.
+
+---
+
+## Liens utiles
+
+- [Guide des packages d'adaptateurs de compatibilité](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/compat/index.md)
+- [Dictionnaires dynamiques - Collections & Variants](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/index.md)
+- [Référence de configuration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/configuration.md)

package/docs/fr/roadmap.md

@@ -29,6 +29,12 @@ Intlayer est une solution de gestion de contenu et d'internationalisation conçu
 
 ---
 
+## Table des matières
+
+<TOC/>
+
+---
+
 ## Fonctionnalités actuelles
 
 ### 1. Déclaration de contenu

package/docs/hi/CI_CD.md

@@ -26,6 +26,10 @@ author: aymericzip
 
 Intlayer आपके सामग्री घोषणा फ़ाइलों के लिए अनुवादों का स्वचालित उत्पादन करने की अनुमति देता है। आपके कार्यप्रवाह के आधार पर इसे प्राप्त करने के कई तरीके हैं।
 
+## विषय सूची
+
+<TOC/>
+
 ## CMS का उपयोग करना
 
 Intlayer के साथ, आप एक ऐसा कार्यप्रवाह अपना सकते हैं जहाँ केवल एक ही स्थानीय भाषा स्थानीय रूप से घोषित की जाती है, जबकि सभी अनुवाद CMS के माध्यम से दूरस्थ रूप से प्रबंधित किए जाते हैं। यह सामग्री और अनुवादों को कोडबेस से पूरी तरह से अलग करने की अनुमति देता है, जिससे सामग्री संपादकों के लिए अधिक लचीलापन मिलता है और हॉट कंटेंट रीलोडिंग सक्षम होती है (परिवर्तन लागू करने के लिए एप्लिकेशन को पुनः निर्माण करने की आवश्यकता नहीं होती)।

package/docs/hi/autoFill.md

@@ -28,6 +28,53 @@ history:
 author: aymericzip
 ---
 
+# कंटेंट डिक्लेरेशन फ़ाइल अनुवाद भरें
+
+**अपने CI में कंटेंट डिक्लेरेशन फ़ाइलों को ऑटोफिल करना** आपके विकास वर्कफ़्लो को तेज़ करने का एक तरीका है।
+
+## व्यवहार को समझना
+
+`fill` कमांड में दो मोड शामिल हैं:
+
+- **Complete**: प्रत्येक locale के लिए सभी missing content को स्वचालित रूप से भरें और वर्तमान फ़ाइल को संपादित करें, या यदि निर्दिष्ट हो तो दूसरी फ़ाइल को संपादित करें। यानी, complete मोड पहले से से अनुवादित मौजूदा content को छोड़ देगा।
+- **Review**: प्रत्येक locale के लिए **सभी** content को स्वचालित रूप से भरें और एक विशिष्ट फ़ाइल के लिए generate करें, या यदि निर्दिष्ट हो तो दूसरी फ़ाइल के लिए generate करें।
+
+`fill` कमांड आपकी सभी locale content declaration files को process करेगा। यानी, यह CMS से आपकी remote content को process नहीं करेगा। CMS के पास अपना स्वयं का translations management है।
+यदि आप `@intlayer/sync-json-plugin` जैसे plugins का उपयोग करते हैं, तो Intlayer JSON files को locale content declaration files में transform करेगा। यानी, वे `fill` कमांड द्वारा process किए जाएंगे।
+
+नई generated files में एक `filled` instruction को dictionary metadata के रूप में शामिल है। यह instruction Intlayer को यह जानने के लिए उपयोग किया जाएगा कि फ़ाइल को autofilled किया गया है या नहीं, और यदि मौजूद है तो इस फ़ाइल को फिर से translate किए जाने से छोड़ दें।
+
+Intlayer autofill के लिए निम्नलिखित instruction पर भी विचार करेगा:
+
+- आपकी `.content.{ts|js|json}` → `fill` instruction से
+- आपकी configuration file `.intlayer.config.ts` → `dictionary.fill` instruction से
+- अन्यथा `true` पर set किया जाएगा
+
+Per-locale content declaration files के लिए, `true` instruction को `./{{fileName}}.fill.content.json` से replace किया जाएगा। यह इसलिए है क्योंकि एक per-locale content declaration file अतिरिक्त localized content प्राप्त नहीं कर सकता है। इसलिए यह मौजूदा फ़ाइल को overwrite न करने के लिए एक नई फ़ाइल generate करेगा।
+
+## डिफ़ॉल्ट व्यवहार
+
+डिफ़ॉल्ट रूप से, `fill` को globally `true` पर सेट किया गया है, जिसका अर्थ है कि Intlayer automatically सभी content files को fill करेगा और फ़ाइल को स्वयं edit करेगा। इस व्यवहार को कई तरीकों से customize किया जा सकता है:
+
+### वैश्विक कॉन्फ़िगरेशन विकल्प
+
+1. **`fill: true` (डिफ़ॉल्ट)** - सभी locales को स्वचालित रूप से भरें और वर्तमान फ़ाइल को संपादित करें
+2. **`fill: false`** - इस सामग्री फ़ाइल के लिए स्वचालित भरण अक्षम करें
+3. **`fill: "./relative/path/to/file"`** - वर्तमान फ़ाइल को संपादित किए बिना निर्दिष्ट फ़ाइल को बनाएं/अपडेट करें, वर्तमान फ़ाइल के स्थान के आधार पर हल किए गए सापेक्ष पथ की ओर इशारा करके
+4. **`fill: "/absolute/path/to/file"`** - वर्तमान फ़ाइल को संपादित किए बिना निर्दिष्ट फ़ाइल को बनाएं/अपडेट करें, कॉन्फ़िगरेशन फ़ाइल `.intlayer.config.ts` में बेस डायरेक्टरी (फ़ील्ड `baseDir`) के आधार पर हल किए गए सापेक्ष पथ की ओर इशारा करके
+5. **`fill: "C:\\absolute\path\to\file"`** - वर्तमान फ़ाइल को संपादित किए बिना निर्दिष्ट फ़ाइल को बनाएं/अपडेट करें, आपके ऑपरेटिंग सिस्टम के आधार पर हल किए गए निरपेक्ष पथ की ओर इशारा करके
+6. **`fill: { [key in Locales]?: string }`** - प्रत्येक locale के लिए निर्दिष्ट फ़ाइल को बनाएं/अपडेट करें
+
+### v7 व्यवहार परिवर्तन
+
+v7 में, `fill` कमांड का व्यवहार अपडेट किया गया है:
+
+- **`fill: true`** - वर्तमान फ़ाइल को सभी locales के लिए भरी गई सामग्री के साथ फिर से लिखता है
+- **`fill: "path/to/file"`** - निर्दिष्ट फ़ाइल को भरता है बिना वर्तमान फ़ाइल को संशोधित किए
+- **`fill: false`** - auto-fill को पूरी तरह अक्षम करता है
+
+जब किसी दूसरी फ़ाइल में लिखने के लिए path विकल्प का उपयोग करते हैं, तो fill तंत्र सामग्री घोषणा फ़ाइलों के बीच एक _master-slave_ संबंध के माध्यम से काम करता है। मुख्य (master) फ़ाइल सत्य का स्रोत है, और जब इसे अपडेट किया जाता है, तो Intlayer स्वचालित रूप से उन परिवर्तनों को path द्वारा निर्दिष्ट व्युत्पन्न (भरी गई) घोषणा फ़ाइलों पर लागू करता है।
+
 # ऑटोफिल सामग्री घोषणा फ़ाइल अनुवाद
 
 **ऑटोफिल सामग्री घोषणा फ़ाइलें** आपके विकास कार्यप्रवाह को तेज़ करने का एक तरीका हैं।
@@ -88,6 +135,40 @@ Intlayer स्वचालित रूप से व्युत्पन्
 
 इसके बाद, दोनों घोषणा फ़ाइलों को एकल शब्दकोश में मर्ज किया जाएगा, जिसे मानक `useIntlayer("example")` हुक (react) / कॉम्पोज़ेबल (vue) का उपयोग करके एक्सेस किया जा सकता है।
 
+## Global Configuration
+
+आप `intlayer.config.ts` फ़ाइल में global auto fill configuration को कॉन्फ़िगर कर सकते हैं।
+
+```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: {
+    // सभी dictionaries के लिए लापता translations को auto-generate करें
+    fill: "./{{fileName}}Filled.content.ts",
+    //
+    // fill: "/messages/{{locale}}/{{key}}/{{fileName}}.content.json",
+    //
+    // fill: true, // सभी dictionaries के लिए लापता translations को auto-generate करें जैसे "./{{fileName}}.content.json" का उपयोग करना
+    //
+    // fill: {
+    //   en: "./{{fileName}}.en.content.json",
+    //   fr: "./{{fileName}}.fr.content.json",
+    //   es: "./{{fileName}}.es.content.json",
+    // },
+  },
+};
+
+export default config;
+```
+
+आप content files में `fill` field का उपयोग करके प्रति dictionary को fine-tune कर सकते हैं। Intlayer पहले per dictionary configuration पर विचार करेगा और फिर global configuration पर fallback करेगा।
+
 ## ऑटोफिल की गई फ़ाइल प्रारूप
 
 सिफारिश की गई स्वरूप ऑटोफिल की गई घोषणा फ़ाइलों के लिए **JSON** है, जो स्वरूपण प्रतिबंधों से बचने में मदद करता है। हालांकि, Intlayer `.ts`, `.js`, `.mjs`, `.cjs`, और अन्य स्वरूपों का भी समर्थन करता है।