@intlayer/docs 9.3.2 → 9.3.3

package/docs/fr/configuration.md

@@ -478,6 +478,30 @@ const config: IntlayerConfig = {
      */
     purge: true,
 
+    /**
+     * Regrouper les chunks de dictionnaire par locale selon la frontière de
+     * code-splitting qui les utilise, pour qu'une page chargée paresseusement
+     * récupère son contenu en une seule requête.
+     * Par défaut : true
+     *
+     * Note :
+     * - S'applique uniquement aux dictionnaires utilisant `importMode: 'dynamic'`.
+     */
+    chunkGrouping: true,
+
+    /**
+     * Charger un dictionnaire en même temps que le chunk qui l'utilise, au lieu de
+     * le récupérer une fois ce chunk rendu. Les lecteurs s'affichent de façon
+     * synchrone au lieu de suspendre, donc la navigation ne fait plus clignoter
+     * d'état de chargement.
+     * Par défaut : true
+     *
+     * Note :
+     * - Seule la locale résolue est attendue, la page ne télécharge donc que la
+     *   langue qu'elle affiche.
+     */
+    dictionariesPreload: true,
+
     /**
      * Format de sortie pour les fichiers de dictionnaire générés.
      * Par défaut : ['cjs', 'esm']
@@ -1058,15 +1082,17 @@ Les options de build s'appliquent aux plugins `@intlayer/babel` et `@intlayer/sw
 
 > Lorsqu'il est optimisé, Intlayer remplacera les appels de dictionnaire pour optimiser le chunking, de sorte que le bundle final n'importe que les dictionnaires réellement utilisés.
 
-| Champ             | Description                                                                   | Type                             | Par défaut                                                                                                                                                                        | Exemple                                                                       | Note                                                                                                                                                                                                                                                                                                                                     |
-| ----------------- | ----------------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mode`            | Contrôle le mode du build.                                                    | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: build activé automatiquement lors du build de l'application.<br/>• `'manual'`: ne s'exécute que lorsque la commande de build est exécutée.<br/>• Peut être utilisé pour désactiver les builds de dictionnaires (ex: pour éviter l'exécution dans des environnements Node.js).                                                |
-| `optimize`        | Contrôle si le build doit être optimisé.                                      | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • Si non défini, l'optimisation est déclenchée lors du build du framework (Vite/Next.js).<br/>• `true` force l'optimisation y compris en mode dev.<br/>• `false` la désactive.<br/>• Une fois activé, remplace les appels de dictionnaire pour optimiser le chunking.<br/>• Repose sur les plugins `@intlayer/babel` et `@intlayer/swc`. |
-| `minify`          | Minifier les dictionnaires pour réduire la taille du bundle.                  | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indique si le bundle doit être minifié.<br/>• Par défaut : `true` en production.<br/>• Cette option sera ignorée si `optimize` est désactivé.<br/>• Cette option sera ignorée si `editor.enabled` est vrai.                                                                                                                            |
-| `purge`           | Purger les clés inutilisées dans les dictionnaires.                           | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indique si le bundle doit être purgé.<br/>• Par défaut : `true` en production.<br/>• Cette option sera ignorée si `optimize` est désactivé.                                                                                                                                                                                            |
-| `checkTypes`      | Indique si le build doit vérifier les types TypeScript et loguer les erreurs. | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | Peut ralentir le build.                                                                                                                                                                                                                                                                                                                  |
-| `outputFormat`    | Contrôle le format de sortie des dictionnaires.                               | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                                          |
-| `traversePattern` | Motifs définissant quels fichiers parcourir lors de l'optimisation.           | `string[]`                       | `['**/*.{tsx,ts,js,mjs,cjs,jsx,vue,svelte,svte}', '!**/node_modules/**', '!**/dist/**', '!**/.intlayer/**', '!**/*.config.*', '!**/*.test.*', '!**/*.spec.*', '!**/*.stories.*']` | `['src/**/*.{ts,tsx}', '../ui-library/**/*.{ts,tsx}', '!**/node_modules/**']` | • Limitez l'optimisation aux fichiers pertinents pour améliorer les performances de build.<br/>• Ignoré si `optimize` est désactivé.<br/>• Utilise des motifs glob.                                                                                                                                                                      |
+| Champ                 | Description                                                                                                               | Type                             | Par défaut                                                                                                                                                                        | Exemple                                                                       | Note                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mode`                | Contrôle le mode du build.                                                                                                | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: build activé automatiquement lors du build de l'application.<br/>• `'manual'`: ne s'exécute que lorsque la commande de build est exécutée.<br/>• Peut être utilisé pour désactiver les builds de dictionnaires (ex: pour éviter l'exécution dans des environnements Node.js).                                                                                                                                                                                                                                                                                                                             |
+| `optimize`            | Contrôle si le build doit être optimisé.                                                                                  | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • Si non défini, l'optimisation est déclenchée lors du build du framework (Vite/Next.js).<br/>• `true` force l'optimisation y compris en mode dev.<br/>• `false` la désactive.<br/>• Une fois activé, remplace les appels de dictionnaire pour optimiser le chunking.<br/>• Repose sur les plugins `@intlayer/babel` et `@intlayer/swc`.                                                                                                                                                                                                                                                                              |
+| `minify`              | Minifier les dictionnaires pour réduire la taille du bundle.                                                              | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indique si le bundle doit être minifié.<br/>• Par défaut : `true` en production.<br/>• Cette option sera ignorée si `optimize` est désactivé.<br/>• Cette option sera ignorée si `editor.enabled` est vrai.                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `purge`               | Purger les clés inutilisées dans les dictionnaires.                                                                       | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indique si le bundle doit être purgé.<br/>• Par défaut : `true` en production.<br/>• Cette option sera ignorée si `optimize` est désactivé.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `checkTypes`          | Indique si le build doit vérifier les types TypeScript et loguer les erreurs.                                             | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | Peut ralentir le build.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `chunkGrouping`       | Indique s'il faut regrouper les chunks de dictionnaire par locale selon la frontière de code-splitting qui les utilise.   | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • Sans regroupement, une page composée de nombreux composants émet une requête par dictionnaire.<br/>• Les dictionnaires atteints depuis plusieurs frontières sont placés dans un chunk partagé, aucune page n'embarque donc le contenu d'une autre.<br/>• S'applique uniquement aux dictionnaires utilisant `importMode: 'dynamic'`.<br/>• S'applique uniquement au build client, et uniquement lors du bundling (pas en dev).                                                                                                                                                                                       |
+| `dictionariesPreload` | Indique si un dictionnaire doit être chargé avec le chunk qui l'utilise, au lieu d'être récupéré une fois ce chunk rendu. | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • Le point d'entrée généré attend la locale de navigation au niveau racine, une route chargée paresseusement n'est donc pas considérée comme chargée tant que son contenu n'est pas là.<br/>• Les lecteurs s'affichent de façon synchrone au lieu de suspendre, la navigation ne fait donc plus clignoter d'état de chargement.<br/>• Seule la locale résolue est attendue, la page ne télécharge donc que la langue qu'elle affiche.<br/>• S'applique uniquement aux dictionnaires utilisant `importMode: 'dynamic'`, sur le build client.<br/>• Nécessite un bundler supportant le top-level await (Vite, esbuild). |
+| `outputFormat`        | Contrôle le format de sortie des dictionnaires.                                                                           | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `traversePattern`     | Motifs définissant quels fichiers parcourir lors de l'optimisation.                                                       | `string[]`                       | `['**/*.{tsx,ts,js,mjs,cjs,jsx,vue,svelte,svte}', '!**/node_modules/**', '!**/dist/**', '!**/.intlayer/**', '!**/*.config.*', '!**/*.test.*', '!**/*.spec.*', '!**/*.stories.*']` | `['src/**/*.{ts,tsx}', '../ui-library/**/*.{ts,tsx}', '!**/node_modules/**']` | • Limitez l'optimisation aux fichiers pertinents pour améliorer les performances de build.<br/>• Ignoré si `optimize` est désactivé.<br/>• Utilise des motifs glob.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 
 ---
 

package/docs/fr/dictionary/content_file.md

@@ -532,28 +532,6 @@ Utilisé en conjonction avec les Variantes, ce champ définit des alternatives d
 
 > Voir [Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/variants.md) pour plus d'informations.
 
-#### `meta` (`Record<string, string | number | boolean>`)
-
-Utilisé en conjonction avec les Enregistrements Dynamiques, ce champ permet de déclarer des enregistrements gérés par le CMS ou des données arbitraires récupérées à l'exécution par un identifiant opaque. L'identité du dictionnaire est définie par l'ensemble arbitraire de paires clé-valeur déclarées dans ce champ `meta`.
-
-**Exemple :**
-
-```typescript
-{
-  key: "product-copy",
-  meta: {
-    id: "prod_abc",
-    userId: "user_123"
-  },
-  content: {
-    name: "Widget Pro",
-    description: "The best widget."
-  }
-}
-```
-
-> Voir [Enregistrements Dynamiques](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/dynamic_content.md) pour plus d'informations.
-
 ### Propriétés CMS
 
 ##### `version` (string)

package/docs/fr/dictionary/function_fetching.md

@@ -89,6 +89,29 @@ Impossible de récupérer du contenu depuis un fichier JSON, utilisez plutôt un
 
 Dans ce cas, la fonction `fakeFetch` imite un délai pour simuler le temps de réponse du serveur. Intlayer exécute la fonction asynchrone et utilise le résultat comme contenu pour la clé `text`.
 
+## Récupération de contenu distant
+
+Vous pouvez également assigner directement une promesse à un champ de contenu. Intlayer l'attend lors de la construction des dictionnaires et y insère la valeur résolue :
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import type { Dictionary } from "intlayer";
+
+const remoteContent = {
+  key: "remote_content",
+  content: {
+    externalContent: fetch("https://example.com").then((res) => res.json()),
+  },
+} satisfies Dictionary;
+
+export default remoteContent;
+```
+
+```plaintext fileName="**/*.content.json" contentDeclarationFormat="json"
+Impossible de récupérer du contenu depuis un fichier JSON, utilisez plutôt un fichier .ts ou .js
+```
+
+> La requête est exécutée au moment du build, les données récupérées sont donc un instantané intégré au dictionnaire. Reconstruisez vos dictionnaires pour les actualiser.
+
 ## Utilisation de contenu basé sur une fonction dans les composants React
 
 Pour utiliser un contenu basé sur une fonction dans un composant React, vous devez importer `useIntlayer` depuis `react-intlayer` et l'appeler avec l'ID du contenu pour récupérer ce contenu. Voici un exemple :

package/docs/fr/eslint.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-08-12
-updatedAt: 2026-08-12
+updatedAt: 2026-08-13
 title: Plugin ESLint | Règles de lint pour Intlayer
 description: Détectez les chaînes codées en dur, les appels dynamiques que le compilateur Intlayer ne peut pas optimiser et le contenu de dictionnaire inutilisé, avec eslint-plugin-intlayer. Compatible ESLint et oxlint, sur React, Vue, Svelte, Angular et Astro.
 keywords:
@@ -52,7 +52,7 @@ pnpm add --save-dev eslint-plugin-intlayer
 yarn add --dev eslint-plugin-intlayer
 ```
 
-Nécessite ESLint 9 ou une version ultérieure (flat config).
+Nécessite ESLint 9 ou une version ultérieure (flat config). ESLint 10 est pris en charge.
 
 ## Utilisation
 
@@ -61,20 +61,20 @@ Le plugin fonctionne à la fois avec ESLint et [oxlint](https://oxc.rs) — mêm
 <Tabs defaultTab="eslint">
   <Tab label="ESLint" value="eslint">
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 import intlayer from "eslint-plugin-intlayer";
 
 export default [...intlayer.configs.recommended];
 ```
 
-Ou activez les règles une par une :
+Ou étalez une config et définissez vous-même les niveaux de sévérité :
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 import intlayer from "eslint-plugin-intlayer";
 
 export default [
+  ...intlayer.configs.recommended,
   {
-    plugins: { intlayer },
     rules: {
       "intlayer/no-raw-text": "warn",
       "intlayer/static-dictionary-key": "error",
@@ -144,7 +144,7 @@ Pour corriger tout un fichier d'un coup, lancez `npx intlayer extract` et laisse
 
 **Options**
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 {
   "intlayer/no-raw-text": [
     "warn",
@@ -247,7 +247,7 @@ Contrairement aux autres règles, celle-ci ne peut pas répondre uniquement à p
 
 **Options**
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 {
   "intlayer/no-unused-content": [
     "warn",
@@ -296,7 +296,7 @@ Toutes les règles fonctionnent sur l'ensemble des intégrations Intlayer, y com
 | Templates Angular         | `.component.html` | `@angular-eslint/template-parser` |
 | Astro                     | `.astro`          | `astro-eslint-parser`             |
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 import intlayer from "eslint-plugin-intlayer";
 import tseslint from "typescript-eslint";
 import vueParser from "vue-eslint-parser";

package/docs/hi/configuration.md

@@ -471,6 +471,30 @@ const config: IntlayerConfig = {
      */
     prune: true,
 
+    /**
+     * प्रति-लोकेल डिक्शनरी चंक्स को उस कोड-स्प्लिट सीमा के अनुसार समूहित करें जो
+     * उनका उपयोग करती है, ताकि आलसी रूप से लोड होने वाला पेज अपनी सामग्री एक ही
+     * अनुरोध में प्राप्त करे।
+     * डिफ़ॉल्ट: true
+     *
+     * नोट:
+     * - केवल `importMode: 'dynamic'` का उपयोग करने वाली डिक्शनरियों पर लागू होता
+     *   है।
+     */
+    chunkGrouping: true,
+
+    /**
+     * डिक्शनरी को उस चंक के साथ लोड करें जो उसका उपयोग करता है, बजाय उस चंक के
+     * रेंडर होने के बाद उसे प्राप्त करने के। पठन सस्पेंड होने के बजाय समकालिक रूप
+     * से रेंडर होते हैं, इसलिए नेविगेशन में अब लोडिंग स्थिति नहीं झलकती।
+     * डिफ़ॉल्ट: true
+     *
+     * नोट:
+     * - केवल हल की गई लोकेल की प्रतीक्षा की जाती है, इसलिए पेज केवल वही भाषा
+     *   डाउनलोड करता है जो वह दिखाता है।
+     */
+    dictionariesPreload: true,
+
     /**
      * जेनरेट की गई डिक्शनरी फ़ाइलों के लिए आउटपुट स्वरूप।
      * डिफ़ॉल्ट: ['cjs', 'esm']
@@ -1047,15 +1071,17 @@ Intlayer आपके एप्लिकेशन के अंतर्रा
 
 > ऑप्टिमाइज़ेशन के दौरान, Intlayer कोड स्प्लिटिंग (chunking) को ऑप्टिमाइज़ करने के लिए डिक्शनरी कॉल को बदल देगा ताकि परिणामी बंडल केवल उन्हीं डिक्शनरी को आयात करे जो वास्तव में उपयोग की जाती हैं।
 
-| फ़ील्ड            | विवरण                                                                                                  | टाइप                             | डिफ़ॉल्ट                                                                                                                                                                          | उदाहरण                                                                        | टिप्पणी                                                                                                                                                                                                                                                                                                                                            |
-| ----------------- | ------------------------------------------------------------------------------------------------------ | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mode`            | बिल्ड मोड को नियंत्रित करता है।                                                                        | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: एप्लिकेशन बिल्ड के दौरान बिल्ड स्वचालित रूप से शुरू होता है।<br/>• `'manual'`: केवल एक स्पष्ट बिल्ड कमांड पर निष्पादित होता है।<br/>• डिक्शनरी बिल्ड को बंद करने के लिए उपयोग किया जा सकता है (जैसे Node.js परिवेशों में चलने से बचने के लिए)।                                                                                         |
-| `optimize`        | नियंत्रित करता है कि बिल्ड ऑप्टिमाइज़ेशन होना चाहिए या नहीं।                                           | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • यदि परिभाषित नहीं है, तो फ्रेमवर्क बिल्ड (Vite/Next.js) के दौरान ऑप्टिमाइज़ेशन शुरू होता है।<br/>• `true` देव मोड में भी ऑप्टिमाइज़ेशन को बाध्य करता है।<br/>• `false` इसे बंद कर देता है।<br/>• चालू होने पर, चंकिंग ऑप्टिमाइज़ेशन के लिए डिक्शनरी कॉल को बदल देता है।<br/>• `@intlayer/babel` और `@intlayer/swc` प्लगइन्स की आवश्यकता होती है। |
-| `minify`          | इंगित करता है कि बंडल के आकार को कम करने के लिए डिक्शनरी को मिनिअफ़ाइ किया जाना चाहिए या नहीं।         | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • बंडल को मिनिअफ़ाइ किया जाना चाहिए या नहीं।<br/>• डिफ़ॉल्ट: प्रोडक्शन में `true`।<br/>• `optimize` अक्षम होने पर यह विकल्प अनदेखा किया जाएगा।<br/>• `editor.enabled` सत्य होने पर यह विकल्प अनदेखा किया जाएगा।                                                                                                                                    |
-| `prune`           | इंगित करता है कि डिक्शनरी में अप्रयुक्त कीज़ (unused keys) को हटाया जाना चाहिए या नहीं।                | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • बंडल को छोटा (pruned) किया जाना चाहिए या नहीं।<br/>• डिफ़ॉल्ट: प्रोडक्शन में `true`।<br/>• `optimize` अक्षम होने पर यह विकल्प अनदेखा किया जाएगा।                                                                                                                                                                                                 |
-| `checkTypes`      | इंगित करता है कि बिल्ड को TypeScript टाइप्स की जाँच करनी चाहिए और त्रुटियों को लॉग करना चाहिए या नहीं। | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | बिल्ड प्रक्रिया को धीमा कर सकता है।                                                                                                                                                                                                                                                                                                                |
-| `outputFormat`    | डिक्शनरी के आउटपुट स्वरूप को नियंत्रित करता है।                                                        | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                                                    |
-| `traversePattern` | उन फ़ाइलों को परिभाषित करने वाले पैटर्न जिन्हें ऑप्टिमाइज़ेशन के दौरान स्कैन किया जाना चाहिए।          | `string[]`                       | `['**/*.{tsx,ts,js,mjs,cjs,jsx,vue,svelte,svte}', '!**/node_modules/**', '!**/dist/**', '!**/.intlayer/**', '!**/*.config.*', '!**/*.test.*', '!**/*.spec.*', '!**/*.stories.*']` | `['src/**/*.{ts,tsx}', '../ui-library/**/*.{ts,tsx}', '!**/node_modules/**']` | • बिल्ड प्रदर्शन बढ़ाने के लिए ऑप्टिमाइज़ेशन को प्रासंगिक फ़ाइलों तक सीमित करें।<br/>• यदि `optimize` बंद होता, तो अनदेखा कर दिया जाता।<br/>• ग्लोब पैटर्न का उपयोग करता है।                                                                                                                                                                       |
+| फ़ील्ड                | विवरण                                                                                                                | टाइप                             | डिफ़ॉल्ट                                                                                                                                                                          | उदाहरण                                                                        | टिप्पणी                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mode`                | बिल्ड मोड को नियंत्रित करता है।                                                                                      | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: एप्लिकेशन बिल्ड के दौरान बिल्ड स्वचालित रूप से शुरू होता है।<br/>• `'manual'`: केवल एक स्पष्ट बिल्ड कमांड पर निष्पादित होता है।<br/>• डिक्शनरी बिल्ड को बंद करने के लिए उपयोग किया जा सकता है (जैसे Node.js परिवेशों में चलने से बचने के लिए)।                                                                                                                                                                                                                                                                                                            |
+| `optimize`            | नियंत्रित करता है कि बिल्ड ऑप्टिमाइज़ेशन होना चाहिए या नहीं।                                                         | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • यदि परिभाषित नहीं है, तो फ्रेमवर्क बिल्ड (Vite/Next.js) के दौरान ऑप्टिमाइज़ेशन शुरू होता है।<br/>• `true` देव मोड में भी ऑप्टिमाइज़ेशन को बाध्य करता है।<br/>• `false` इसे बंद कर देता है।<br/>• चालू होने पर, चंकिंग ऑप्टिमाइज़ेशन के लिए डिक्शनरी कॉल को बदल देता है।<br/>• `@intlayer/babel` और `@intlayer/swc` प्लगइन्स की आवश्यकता होती है।                                                                                                                                                                                                                    |
+| `minify`              | इंगित करता है कि बंडल के आकार को कम करने के लिए डिक्शनरी को मिनिअफ़ाइ किया जाना चाहिए या नहीं।                       | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • बंडल को मिनिअफ़ाइ किया जाना चाहिए या नहीं।<br/>• डिफ़ॉल्ट: प्रोडक्शन में `true`।<br/>• `optimize` अक्षम होने पर यह विकल्प अनदेखा किया जाएगा।<br/>• `editor.enabled` सत्य होने पर यह विकल्प अनदेखा किया जाएगा।                                                                                                                                                                                                                                                                                                                                                       |
+| `prune`               | इंगित करता है कि डिक्शनरी में अप्रयुक्त कीज़ (unused keys) को हटाया जाना चाहिए या नहीं।                              | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • बंडल को छोटा (pruned) किया जाना चाहिए या नहीं।<br/>• डिफ़ॉल्ट: प्रोडक्शन में `true`।<br/>• `optimize` अक्षम होने पर यह विकल्प अनदेखा किया जाएगा।                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `checkTypes`          | इंगित करता है कि बिल्ड को TypeScript टाइप्स की जाँच करनी चाहिए और त्रुटियों को लॉग करना चाहिए या नहीं।               | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | बिल्ड प्रक्रिया को धीमा कर सकता है।                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `chunkGrouping`       | क्या प्रति-लोकेल डिक्शनरी चंक्स को उस कोड-स्प्लिट सीमा के अनुसार समूहित किया जाए जो उनका उपयोग करती है।              | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • समूहीकरण के बिना, कई घटकों से बना पेज प्रत्येक डिक्शनरी के लिए एक अनुरोध भेजता है।<br/>• कई सीमाओं से पहुँची जाने वाली डिक्शनरियाँ साझा चंक में चली जाती हैं, इसलिए कोई पेज दूसरे पेज की सामग्री नहीं भेजता।<br/>• केवल `importMode: 'dynamic'` का उपयोग करने वाली डिक्शनरियों पर लागू होता है।<br/>• केवल क्लाइंट बिल्ड पर, और केवल बंडलिंग के समय लागू होता है (dev में नहीं)।                                                                                                                                                                                    |
+| `dictionariesPreload` | क्या डिक्शनरी को उस चंक के साथ लोड किया जाए जो उसका उपयोग करता है, बजाय उस चंक के रेंडर होने के बाद प्राप्त करने के। | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • उत्पन्न एंट्री पॉइंट शीर्ष स्तर पर ब्राउज़िंग लोकेल की प्रतीक्षा करता है, इसलिए आलसी रूप से लोड होने वाला रूट तब तक लोड नहीं माना जाता जब तक उसकी सामग्री उपलब्ध न हो।<br/>• पठन सस्पेंड होने के बजाय समकालिक रूप से रेंडर होते हैं, इसलिए नेविगेशन में अब लोडिंग स्थिति नहीं झलकती।<br/>• केवल हल की गई लोकेल की प्रतीक्षा की जाती है, इसलिए पेज केवल वही भाषा डाउनलोड करता है जो वह दिखाता है।<br/>• केवल क्लाइंट बिल्ड में `importMode: 'dynamic'` का उपयोग करने वाली डिक्शनरियों पर लागू होता है।<br/>• टॉप-लेवल await समर्थित बंडलर आवश्यक है (Vite, esbuild)। |
+| `outputFormat`        | डिक्शनरी के आउटपुट स्वरूप को नियंत्रित करता है।                                                                      | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `traversePattern`     | उन फ़ाइलों को परिभाषित करने वाले पैटर्न जिन्हें ऑप्टिमाइज़ेशन के दौरान स्कैन किया जाना चाहिए।                        | `string[]`                       | `['**/*.{tsx,ts,js,mjs,cjs,jsx,vue,svelte,svte}', '!**/node_modules/**', '!**/dist/**', '!**/.intlayer/**', '!**/*.config.*', '!**/*.test.*', '!**/*.spec.*', '!**/*.stories.*']` | `['src/**/*.{ts,tsx}', '../ui-library/**/*.{ts,tsx}', '!**/node_modules/**']` | • बिल्ड प्रदर्शन बढ़ाने के लिए ऑप्टिमाइज़ेशन को प्रासंगिक फ़ाइलों तक सीमित करें।<br/>• यदि `optimize` बंद होता, तो अनदेखा कर दिया जाता।<br/>• ग्लोब पैटर्न का उपयोग करता है।                                                                                                                                                                                                                                                                                                                                                                                          |
 
 ---
 

package/docs/hi/dictionary/content_file.md

@@ -534,28 +534,6 @@ Variants के संयोजन में उपयोग किया जा
 
 > अधिक जानकारी के लिए [Variants](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/variants.md) देखें।
 
-#### `meta` (`Record<string, string | number | boolean>`)
-
-Dynamic Records के संयोजन में उपयोग किया जाने वाला, यह फ़ील्ड एक अपारदर्शी आईडी द्वारा रनटाइम पर CMS-प्रबंधित रिकॉर्ड या मनमाने डेटा की घोषणा करने की अनुमति देता है। शब्दकोश की पहचान इस `meta` फ़ील्ड में घोषित कुंजी-मान जोड़े के मनमाने सेट द्वारा परिभाषित होती है।
-
-**उदाहरण:**
-
-```typescript
-{
-  key: "product-copy",
-  meta: {
-    id: "prod_abc",
-    userId: "user_123"
-  },
-  content: {
-    name: "Widget Pro",
-    description: "The best widget."
-  }
-}
-```
-
-> अधिक जानकारी के लिए [Dynamic Records](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/dynamic_content.md) देखें।
-
 ### CMS गुण
 
 ##### `version` (स्ट्रिंग)

package/docs/hi/dictionary/function_fetching.md

@@ -89,6 +89,29 @@ JSON फ़ाइल से सामग्री प्राप्त कर
 
 इस मामले में, `fakeFetch` फ़ंक्शन सर्वर प्रतिक्रिया समय का अनुकरण करने के लिए एक विलंब का अनुकरण करता है। Intlayer असिंक्रोनस फ़ंक्शन को निष्पादित करता है और परिणाम को `text` कुंजी के लिए सामग्री के रूप में उपयोग करता है।
 
+## रिमोट सामग्री प्राप्त करना
+
+आप किसी सामग्री फ़ील्ड को सीधे एक प्रॉमिस भी सौंप सकते हैं। Intlayer डिक्शनरी बनाते समय उसका इंतज़ार करता है और हल हुए मान को उसमें शामिल कर देता है:
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import type { Dictionary } from "intlayer";
+
+const remoteContent = {
+  key: "remote_content",
+  content: {
+    externalContent: fetch("https://example.com").then((res) => res.json()),
+  },
+} satisfies Dictionary;
+
+export default remoteContent;
+```
+
+```plaintext fileName="**/*.content.json" contentDeclarationFormat="json"
+JSON फ़ाइल से सामग्री प्राप्त करने का कोई तरीका नहीं है, इसके बजाय .ts या .js फ़ाइल का उपयोग करें
+```
+
+> अनुरोध बिल्ड समय पर चलता है, इसलिए प्राप्त डेटा डिक्शनरी में एम्बेड किया गया एक स्नैपशॉट होता है। इसे ताज़ा करने के लिए अपनी डिक्शनरी दोबारा बनाएं।
+
 ## React घटकों में फ़ंक्शन-आधारित सामग्री का उपयोग करना
 
 React घटक में फ़ंक्शन-आधारित सामग्री का उपयोग करने के लिए, आपको `react-intlayer` से `useIntlayer` आयात करना होगा और सामग्री प्राप्त करने के लिए इसे सामग्री आईडी के साथ कॉल करना होगा। यहाँ एक उदाहरण है:

package/docs/hi/eslint.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-08-12
-updatedAt: 2026-08-12
+updatedAt: 2026-08-13
 title: ESLint प्लगइन | Intlayer के लिए लिंट नियम
 description: eslint-plugin-intlayer के साथ हार्डकोडेड स्ट्रिंग्स, ऐसे डायनामिक कॉल्स जिन्हें Intlayer कंपाइलर ऑप्टिमाइज़ नहीं कर सकता, और अप्रयुक्त शब्दकोश सामग्री का पता लगाएं। React, Vue, Svelte, Angular और Astro में ESLint और oxlint के साथ काम करता है।
 keywords:
@@ -52,7 +52,7 @@ pnpm add --save-dev eslint-plugin-intlayer
 yarn add --dev eslint-plugin-intlayer
 ```
 
-ESLint 9 या बाद के संस्करण (flat config) की आवश्यकता है।
+ESLint 9 या बाद के संस्करण (flat config) की आवश्यकता है। ESLint 10 समर्थित है।
 
 ## उपयोग
 
@@ -61,20 +61,20 @@ ESLint 9 या बाद के संस्करण (flat config) की आ
 <Tabs defaultTab="eslint">
   <Tab label="ESLint" value="eslint">
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 import intlayer from "eslint-plugin-intlayer";
 
 export default [...intlayer.configs.recommended];
 ```
 
-या नियमों को एक-एक करके सक्षम करें:
+या किसी कॉन्फ़िग को फैलाएँ और गंभीरता स्वयं तय करें:
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 import intlayer from "eslint-plugin-intlayer";
 
 export default [
+  ...intlayer.configs.recommended,
   {
-    plugins: { intlayer },
     rules: {
       "intlayer/no-raw-text": "warn",
       "intlayer/static-dictionary-key": "error",
@@ -144,7 +144,7 @@ const { title } = useIntlayer("home");
 
 **विकल्प**
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 {
   "intlayer/no-raw-text": [
     "warn",
@@ -247,7 +247,7 @@ export default {
 
 **विकल्प**
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 {
   "intlayer/no-unused-content": [
     "warn",
@@ -296,7 +296,7 @@ export default {
 | Angular टेम्प्लेट्स       | `.component.html` | `@angular-eslint/template-parser` |
 | Astro                     | `.astro`          | `astro-eslint-parser`             |
 
-```javascript fileName="eslint.config.mjs" codeFormat="esm"
+```javascript fileName="eslint.config.mjs"
 import intlayer from "eslint-plugin-intlayer";
 import tseslint from "typescript-eslint";
 import vueParser from "vue-eslint-parser";

package/docs/id/configuration.md

@@ -478,6 +478,30 @@ const config: IntlayerConfig = {
      */
     purge: true,
 
+    /**
+     * Kelompokkan potongan kamus per lokal berdasarkan batas pemisahan kode yang
+     * menggunakannya, sehingga halaman yang dimuat secara lazy mengambil kontennya
+     * dalam satu permintaan.
+     * Default: true
+     *
+     * Catatan:
+     * - Hanya berlaku untuk kamus yang menggunakan `importMode: 'dynamic'`.
+     */
+    chunkGrouping: true,
+
+    /**
+     * Muat kamus bersama potongan yang menggunakannya, alih-alih mengambilnya
+     * setelah potongan tersebut dirender. Pembacaan dirender secara sinkron
+     * alih-alih ditangguhkan, sehingga navigasi tidak lagi menampilkan kedipan
+     * status pemuatan.
+     * Default: true
+     *
+     * Catatan:
+     * - Hanya lokal yang telah ditentukan yang ditunggu, sehingga halaman hanya
+     *   mengunduh bahasa yang ditampilkannya.
+     */
+    dictionariesPreload: true,
+
     /**
      * Format output untuk file kamus yang dihasilkan.
      * Default: ['cjs', 'esm']
@@ -1054,15 +1078,17 @@ Pengaturan build berlaku untuk plugin `@intlayer/babel` dan `@intlayer/swc`.
 
 > Selama optimasi, Intlayer mengganti panggilan kamus dengan optimasi pemisahan kode (chunking) sehingga bundel akhir hanya mengimpor kamus yang benar-benar digunakan.
 
-| Bidang            | Deskripsi                                                                    | Tipe                             | Default                                                                                                                                                                           | Contoh                                                                        | Catatan                                                                                                                                                                                                                                                                                                                    |
-| ----------------- | ---------------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mode`            | Mengontrol mode eksekusi build.                                              | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: Build dipicu secara otomatis selama build aplikasi.<br/>• `'manual'`: Hanya dijalankan melalui perintah build eksplisit.<br/>• Dapat berguna untuk mencegah build kamus (misalnya: untuk menghindari eksekusi di lingkungan Node.js).                                                                          |
-| `optimize`        | Mengontrol apakah optimasi build dilakukan.                                  | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • Jika tidak ditentukan, ini akan dipicu selama build framework (Vite/Next.js).<br/>• `true` memaksakan optimasi bahkan dalam mode pengembangan.<br/>• `false` menonaktifkannya.<br/>• Jika diaktifkan, mengganti panggilan kamus dengan optimasi chunking.<br/>• Memerlukan plugin `@intlayer/babel` dan `@intlayer/swc`. |
-| `minify`          | Minifikasikan kamus untuk mengurangi ukuran bundle.                          | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Apakah bundel harus diminifikasi.<br/>• Default: `false` dalam produksi.<br/>• Opsi ini akan diabaikan jika `optimize` dinonaktifkan.<br/>• Opsi ini akan diabaikan jika `editor.enabled` adalah true.                                                                                                                   |
-| `purge`           | Bersihkan kunci yang tidak digunakan dalam kamus.                            | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Apakah bundel harus dibersihkan.<br/>• Default: `false` dalam produksi.<br/>• Opsi ini akan diabaikan jika `optimize` dinonaktifkan.                                                                                                                                                                                     |
-| `checkTypes`      | Menunjukkan apakah build harus memeriksa tipe TypeScript dan mencatat error. | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | Dapat memperlambat performa build.                                                                                                                                                                                                                                                                                         |
-| `outputFormat`    | Mengontrol format output kamus.                                              | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                            |
-| `traversePattern` | Pola untuk file yang akan dipindai selama optimasi.                          | `string[]`                       | `['**/*.{tsx,ts,js,mjs,cjs,jsx,vue,svelte,svte}', '!**/node_modules/**', '!**/dist/**', '!**/.intlayer/**', '!**/*.config.*', '!**/*.test.*', '!**/*.spec.*', '!**/*.stories.*']` | `['src/**/*.{ts,tsx}', '../ui-library/**/*.{ts,tsx}', '!**/node_modules/**']` | • Meningkatkan performa build dengan membatasi optimasi ke file yang relevan.<br/>• Diabaikan jika `optimize` dinonaktifkan.<br/>• Menggunakan pola glob.                                                                                                                                                                  |
+| Bidang                | Deskripsi                                                                                                                        | Tipe                             | Default                                                                                                                                                                           | Contoh                                                                        | Catatan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mode`                | Mengontrol mode eksekusi build.                                                                                                  | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: Build dipicu secara otomatis selama build aplikasi.<br/>• `'manual'`: Hanya dijalankan melalui perintah build eksplisit.<br/>• Dapat berguna untuk mencegah build kamus (misalnya: untuk menghindari eksekusi di lingkungan Node.js).                                                                                                                                                                                                                                                                                                                                               |
+| `optimize`            | Mengontrol apakah optimasi build dilakukan.                                                                                      | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • Jika tidak ditentukan, ini akan dipicu selama build framework (Vite/Next.js).<br/>• `true` memaksakan optimasi bahkan dalam mode pengembangan.<br/>• `false` menonaktifkannya.<br/>• Jika diaktifkan, mengganti panggilan kamus dengan optimasi chunking.<br/>• Memerlukan plugin `@intlayer/babel` dan `@intlayer/swc`.                                                                                                                                                                                                                                                                      |
+| `minify`              | Minifikasikan kamus untuk mengurangi ukuran bundle.                                                                              | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Apakah bundel harus diminifikasi.<br/>• Default: `false` dalam produksi.<br/>• Opsi ini akan diabaikan jika `optimize` dinonaktifkan.<br/>• Opsi ini akan diabaikan jika `editor.enabled` adalah true.                                                                                                                                                                                                                                                                                                                                                                                        |
+| `purge`               | Bersihkan kunci yang tidak digunakan dalam kamus.                                                                                | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Apakah bundel harus dibersihkan.<br/>• Default: `false` dalam produksi.<br/>• Opsi ini akan diabaikan jika `optimize` dinonaktifkan.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `checkTypes`          | Menunjukkan apakah build harus memeriksa tipe TypeScript dan mencatat error.                                                     | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | Dapat memperlambat performa build.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `chunkGrouping`       | Menentukan apakah potongan kamus per lokal harus dikelompokkan berdasarkan batas pemisahan kode yang menggunakannya.             | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • Tanpa pengelompokan, halaman yang tersusun dari banyak komponen mengirim satu permintaan per kamus.<br/>• Kamus yang dijangkau dari beberapa batas dipindahkan ke potongan bersama, sehingga tidak ada halaman yang membawa konten halaman lain.<br/>• Hanya berlaku untuk kamus yang menggunakan `importMode: 'dynamic'`.<br/>• Hanya berlaku untuk build klien, dan hanya saat bundling (bukan di mode dev).                                                                                                                                                                                |
+| `dictionariesPreload` | Menentukan apakah kamus harus dimuat bersama potongan yang menggunakannya, alih-alih diambil setelah potongan tersebut dirender. | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • Titik masuk yang dihasilkan menunggu lokal penjelajahan di tingkat teratas, sehingga rute yang dimuat secara lazy tidak dianggap dimuat sampai kontennya tersedia.<br/>• Pembacaan dirender secara sinkron alih-alih ditangguhkan, sehingga navigasi tidak lagi menampilkan kedipan status pemuatan.<br/>• Hanya lokal yang telah ditentukan yang ditunggu, sehingga halaman hanya mengunduh bahasa yang ditampilkannya.<br/>• Hanya berlaku untuk kamus yang menggunakan `importMode: 'dynamic'`, pada build klien.<br/>• Memerlukan bundler yang mendukung top-level await (Vite, esbuild). |
+| `outputFormat`        | Mengontrol format output kamus.                                                                                                  | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `traversePattern`     | Pola untuk file yang akan dipindai selama optimasi.                                                                              | `string[]`                       | `['**/*.{tsx,ts,js,mjs,cjs,jsx,vue,svelte,svte}', '!**/node_modules/**', '!**/dist/**', '!**/.intlayer/**', '!**/*.config.*', '!**/*.test.*', '!**/*.spec.*', '!**/*.stories.*']` | `['src/**/*.{ts,tsx}', '../ui-library/**/*.{ts,tsx}', '!**/node_modules/**']` | • Meningkatkan performa build dengan membatasi optimasi ke file yang relevan.<br/>• Diabaikan jika `optimize` dinonaktifkan.<br/>• Menggunakan pola glob.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 
 ---
 

package/docs/id/dictionary/content_file.md

@@ -536,28 +536,6 @@ Digunakan bersama dengan Variants, bidang ini menentukan alternatif konten berna
 
 > Lihat [Variants](https://github.com/aymericzip/intlayer/blob/main/docs/docs/id/dynamic_dictionaries/variants.md) untuk informasi lebih lanjut.
 
-#### `meta` (`Record<string, string | number | boolean>`)
-
-Digunakan bersama dengan Dynamic Records, bidang ini memungkinkan mendeklarasikan record yang dikelola CMS atau data arbitrer yang diambil saat runtime dengan ID buram. Identitas kamus ditentukan oleh kumpulan pasangan kunci-nilai arbitrer yang dideklarasikan dalam bidang `meta` ini.
-
-**Contoh:**
-
-```typescript
-{
-  key: "product-copy",
-  meta: {
-    id: "prod_abc",
-    userId: "user_123"
-  },
-  content: {
-    name: "Widget Pro",
-    description: "The best widget."
-  }
-}
-```
-
-> Lihat [Dynamic Records](https://github.com/aymericzip/intlayer/blob/main/docs/docs/id/dynamic_dictionaries/dynamic_content.md) untuk informasi lebih lanjut.
-
 ### Properti CMS
 
 ##### `version` (string)

package/docs/id/dictionary/function_fetching.md

@@ -89,6 +89,29 @@ Tidak ada cara untuk mengambil konten dari file JSON, gunakan file .ts atau .js
 
 Dalam kasus ini, fungsi `fakeFetch` meniru penundaan untuk mensimulasikan waktu respons server. Intlayer menjalankan fungsi asinkron dan menggunakan hasilnya sebagai konten untuk kunci `text`.
 
+## Mengambil Konten Jarak Jauh
+
+Anda juga dapat menetapkan sebuah promise langsung ke sebuah field konten. Intlayer menunggunya saat membangun kamus dan menyisipkan nilai yang telah diselesaikan:
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import type { Dictionary } from "intlayer";
+
+const remoteContent = {
+  key: "remote_content",
+  content: {
+    externalContent: fetch("https://example.com").then((res) => res.json()),
+  },
+} satisfies Dictionary;
+
+export default remoteContent;
+```
+
+```plaintext fileName="**/*.content.json" contentDeclarationFormat="json"
+Tidak ada cara untuk mengambil konten dari file JSON, gunakan file .ts atau .js sebagai gantinya
+```
+
+> Permintaan dijalankan pada waktu build, sehingga data yang diambil merupakan snapshot yang tertanam di dalam kamus. Bangun ulang kamus Anda untuk memperbaruinya.
+
 ## Menggunakan Konten Berbasis Fungsi dalam Komponen React
 
 Untuk menggunakan konten berbasis fungsi dalam komponen React, Anda perlu mengimpor `useIntlayer` dari `react-intlayer` dan memanggilnya dengan ID konten untuk mengambil konten tersebut. Berikut adalah contohnya: