@intlayer/docs 9.3.1 → 9.3.3

package/docs/cs/eslint.md

@@ -0,0 +1,336 @@
+---
+createdAt: 2026-08-12
+updatedAt: 2026-08-13
+title: Plugin ESLint | Pravidla lintování pro Intlayer
+description: Odhalujte natvrdo zapsané řetězce, dynamická volání, která kompilátor Intlayer nedokáže optimalizovat, a nepoužitý obsah slovníků pomocí eslint-plugin-intlayer. Funguje s ESLint a oxlint v Reactu, Vue, Svelte, Angularu a Astru.
+keywords:
+  - Intlayer
+  - ESLint
+  - oxlint
+  - Linting
+  - i18n
+  - Internacionalizace
+  - no-raw-text
+  - Hardcoded řetězce
+  - Nepoužité překlady
+  - Mrtvý obsah
+  - React
+  - Vue
+  - Svelte
+  - Angular
+slugs:
+  - doc
+  - eslint
+history:
+  - version: 9.3.1
+    date: 2026-08-12
+    changes: "Počáteční historie"
+author: aymericzip
+---
+
+# Plugin ESLint x OXLint
+
+`eslint-plugin-intlayer` zachycuje typy chyb i18n, které TypeScript nedokáže odhalit:
+
+1. **Natvrdo zapsaný text (hardcoded text)**, který nebyl vložen do slovníku.
+2. **Dynamická volání**, která projdou typovou kontrolou a fungují, ale kompilátor Intlayer je nedokáže optimalizovat.
+3. **Mrtvý obsah (Dead content)** — slovníky a pole, které v projektu nic nečte (volitelné / opt-in).
+
+Neznámé klíče slovníků, neznámé cesty polí a chybějící lokality jsou již chybami kompilace, takže je plugin neopakuje.
+
+## Instalace
+
+```bash packageManager="npm"
+npm install --save-dev eslint-plugin-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add --save-dev eslint-plugin-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add --dev eslint-plugin-intlayer
+```
+
+Vyžaduje ESLint 9 nebo novější (flat config). ESLint 10 je podporován.
+
+## Použití
+
+Plugin funguje jak v ESLint, tak v [oxlint](https://oxc.rs) — se stejnými pravidly a možnostmi.
+
+<Tabs defaultTab="eslint">
+  <Tab label="ESLint" value="eslint">
+
+```javascript fileName="eslint.config.mjs"
+import intlayer from "eslint-plugin-intlayer";
+
+export default [...intlayer.configs.recommended];
+```
+
+Nebo rozbalte konfiguraci a závažnosti si nastavte sami:
+
+```javascript fileName="eslint.config.mjs"
+import intlayer from "eslint-plugin-intlayer";
+
+export default [
+  ...intlayer.configs.recommended,
+  {
+    rules: {
+      "intlayer/no-raw-text": "warn",
+      "intlayer/static-dictionary-key": "error",
+      "intlayer/no-dynamic-field-access": "error",
+      "intlayer/enforce-adapter-import": "warn",
+      "intlayer/no-unused-content": "warn",
+    },
+  },
+];
+```
+
+  </Tab>
+  <Tab label="oxlint" value="oxlint">
+
+```json fileName=".oxlintrc.json"
+{
+  "jsPlugins": ["eslint-plugin-intlayer"],
+  "rules": {
+    "intlayer/no-raw-text": "warn",
+    "intlayer/static-dictionary-key": "error",
+    "intlayer/no-dynamic-field-access": "error",
+    "intlayer/enforce-adapter-import": "warn"
+  }
+}
+```
+
+Dvě upozornění: podpora JS pluginů v oxlint je stále ve fázi alfa a oxlint nepodporuje vlastní parsery — proto zde soubory `.vue`, `.svelte`, `.astro` a šablony Angularu nejsou kontrolovány. Spusťte oxlint na souborech JS/TS/JSX a pro zbytek použijte ESLint.
+
+Pravidlo `no-unused-content` je výše záměrně vynecháno: vyžaduje pracovní adresář a cestu ke kontrolovanému souboru z kontextu pravidla, což alfa můstek JS pluginů nezaručuje. Spusťte jej pod ESLintem.
+
+  </Tab>
+</Tabs>
+
+### Konfigurace (Configs)
+
+| Konfigurace     | `no-raw-text`               | `static-dictionary-key` | `no-dynamic-field-access` | `enforce-adapter-import` | `no-unused-content` |
+| --------------- | --------------------------- | ----------------------- | ------------------------- | ------------------------ | ------------------- |
+| `recommended`   | warn                        | error                   | error                     | off                      | off                 |
+| `strict`        | error (+ literály mimo JSX) | error                   | error                     | error                    | off                 |
+| `contract-only` | off                         | error                   | error                     | off                      | off                 |
+
+Předvolba `recommended` záměrně ponechává `no-raw-text` na úrovni `warn`: její spuštění nad existující kódovou bází zobrazí všechny nepřeložené řetězce najednou, což by nemělo rozbít váš build hned první den.
+
+`enforce-adapter-import` je ve výchozím nastavení vypnuto — pokud jej chcete, explicitně jej zapněte.
+
+`no-unused-content` je vypnuto ve všech konfiguracích včetně `strict`. Je to jediné pravidlo, které čte vaši konfiguraci Intlayer a prochází zdrojové soubory z disku, takže jeho zapnutí by mělo být záměrnou volbou, nikoli automatickou předvolbou.
+
+## Pravidla
+
+### `no-raw-text`
+
+Hlásí text určený pro uživatele, který není deklarován ve slovníku. Používá stejnou detekci jako `intlayer extract`, takže názvy značek, třídy CSS a technické identifikátory jsou ignorovány.
+
+```jsx
+// ✗ Nahlášeno
+<h1>Welcome to our documentation</h1>
+<input placeholder="Enter your email address" />
+
+// ✓ V pořádku
+const { title } = useIntlayer("home");
+<h1>{title}</h1>
+```
+
+Soubory deklarace obsahu (`*.content.ts`, …) jsou přeskočeny.
+
+Chcete-li opravit celý soubor najednou, spusťte `npx intlayer extract` a nechte kompilátor přesunout řetězce do slovníku za vás.
+
+**Možnosti**
+
+```javascript fileName="eslint.config.mjs"
+{
+  "intlayer/no-raw-text": [
+    "warn",
+    {
+      // Atributy, jejichž hodnotou je text pro uživatele.
+      // Výchozí: title, placeholder, alt, aria-label, label
+      attributes: ["title", "placeholder", "alt", "aria-label", "label"],
+
+      // Elementy, jejichž obsah nikdy není textem pro uživatele.
+      // Výchozí: code, pre, script, style
+      ignoreElements: ["code", "pre", "script", "style"],
+
+      // Regulární výrazy pro text, který se nemá nikdy hlásit.
+      ignorePatterns: ["^Powered by"],
+
+      // Hlásit také řetězcové literály mimo značky. Výchozí: false
+      includeStringLiterals: false,
+    },
+  ],
+}
+```
+
+### `static-dictionary-key`
+
+Vyžaduje, aby klíč slovníku byl řetězcový literál.
+
+Kompilátor může přednačíst slovník pouze tehdy, když dokáže přečíst klíč přímo v místě volání. Při použití vypočteného klíče optimalizaci tiše přeskočí a místo toho přibalí každý slovník.
+
+```typescript
+// ✗ Nahlášeno
+useIntlayer(dictionaryKey);
+useIntlayer(`home-${suffix}`);
+getTranslations({ namespace: page });
+
+// ✗ Proměnná stále není literál
+const key = "home";
+useIntlayer(key);
+
+// ✓ V pořádku
+useIntlayer("home");
+getTranslations({ namespace: "home" });
+```
+
+To platí pro `useIntlayer`, `getIntlayer` a všechny kompatibilní adaptéry (`useTranslation`, `useTranslations`, `formatMessage`, `<FormattedMessage id>`, `<Trans i18nKey>`, …).
+
+### `no-dynamic-field-access`
+
+Vyžaduje, aby pole, které čtete ze slovníku, bylo staticky známé.
+
+Kompilátor odstraňuje pole, u kterých nevidí využití. Dynamický přístup je pro něj neviditelný, takže čtení může za běhu vrátit `undefined`.
+
+```typescript
+// ✗ Nahlášeno
+const content = useIntlayer("home");
+content[fieldName];
+
+const t = useTranslations("home");
+t(messageKey);
+
+// ✓ V pořádku
+content.title;
+content["title"];
+content.items[0];
+t("hero.title");
+```
+
+### `enforce-adapter-import`
+
+Dává přednost kompatibilnímu adaptéru `@intlayer/*` před původním balíčkem. Původní balíček se na Intlayer překládá pouze při nakonfigurovaném aliasu bundleru; adaptér funguje vždy. Automaticky opravitelné pomocí `--fix`.
+
+```typescript
+// ✗ Nahlášeno
+import { useTranslation } from "react-i18next";
+import { getTranslations } from "next-intl/server";
+
+// ✓ V pořádku
+import { useTranslation } from "@intlayer/react-i18next";
+import { getTranslations } from "@intlayer/next-intl/server";
+```
+
+### `no-unused-content`
+
+**Ve výchozím nastavení vypnuto.** Hlásí obsah, který v projektu nic nečte, a navíc klíče slovníků deklarované na více než jednom místě.
+
+```typescript fileName="src/home.content.ts"
+export default {
+  key: "home", // ✗ Nahlášeno, pokud žádný volající v projektu nežádá "home"
+  content: {
+    title: t({ cs: "Název", en: "Title" }),
+
+    // ✗ Nahlášeno, pokud nic nečte `hero`
+    hero: {
+      subtitle: t({ cs: "Podnázev", en: "Subtitle" }),
+    },
+  },
+};
+```
+
+Na rozdíl od jiných pravidel toto pravidlo nemůže rozhodnout pouze na základě otevřeného souboru — pole je nepoužité pouze ve vztahu k celému projektu. Při první deklaraci obsahu v běhu lintu načte vaši konfiguraci Intlayer, prohledá zdrojové soubory podle konfigurace (`build.traversePattern`, `compiler.transformPattern`) a spustí stejný analyzátor využití, který pohání `@intlayer/lsp` a přeškrtnutí „nepoužitého“ v rozšíření VS Code. Výsledek se ukládá do mezipaměti na `cacheTtl` milisekund, takže skenování proběhne jednou za běh a nikoli pro každý soubor.
+
+**Možnosti**
+
+```javascript fileName="eslint.config.mjs"
+{
+  "intlayer/no-unused-content": [
+    "warn",
+    {
+      // Hlásit klíče slovníků, na které nic neodkazuje. Výchozí: true
+      reportUnusedDictionaries: true,
+
+      // Hlásit pole obsahu, která nic nečte. Výchozí: true
+      reportUnusedFields: true,
+
+      // Hlásit duplicitní klíče deklarované na více místech. Výchozí: true
+      reportDuplicateKeys: true,
+
+      // Regulární výrazy pro cesty polí, které se nemají nikdy hlásit.
+      ignoreFields: ["^meta"],
+
+      // Kořen projektu, od kterého skenování začíná. Výchozí: pracovní adresář ESLint
+      baseDir: process.cwd(),
+
+      // Doba opětovného použití skenu projektu (v ms). Výchozí: 30000
+      cacheTtl: 30000,
+    },
+  ],
+}
+```
+
+Snižte `cacheTtl`, pokud lintujete z dlouhotrvajícího serveru editoru a chcete, aby se úpravy projevily dříve; nastavte `baseDir`, když jeden běh lintu zahrnuje několik projektů Intlayer v monorepu.
+
+> **Přiklání se k tichu.** Falešně pozitivní výsledek by zde smazal překlad, proto se nic nehlásí, pokud je slovník konzumován způsobem, který analýza nedokáže sledovat: objekt obsahu předaný jako celek, překladatelská funkce vázaná z něj (`const t = useTranslations("home")`), deklarace dosažená přímým importem (`useDictionary(myDictionary)`), volání `nest()` z jiného slovníku nebo seznam polí neúplný kvůli operátoru spread. Jednosouborové komponenty (`.vue`, `.svelte`, `.astro`) se počítají jako využívající každé pole zmíněných slovníků, protože jejich bloky skriptů se zde neparsují.
+
+`reportDuplicateKeys` čte nesloučené slovníky, které build zapisuje do `.intlayer/`, takže zůstává neaktivní, dokud projekt nebyl alespoň jednou sestaven. Dvě deklarace sdílející klíč se sloučí, což je legitimní vzor — hlášení existuje proto, že pole definované na obou stranách tiše zachová pouze jednu ze dvou hodnot.
+
+Analyzátor se načítá z `@intlayer/lsp`, který je distribuován jako ESM. Pravidlo proto vyžaduje verzi Node schopnou provést `require()` modulu ES — Node 20.19+ nebo 22.12+. Na starších verzích raději nehlásí nic, než aby způsobilo selhání lintu.
+
+## Frameworky
+
+Každé pravidlo funguje ve všech integracích Intlayer, včetně šablon Vue, Svelte a Angularu. Stačí pouze určit ESLintu, který parser má číst daný typ souboru.
+
+| Framework                 | Soubory           | Parser                            |
+| ------------------------- | ----------------- | --------------------------------- |
+| React, Preact, Solid, Lit | `.jsx` `.tsx`     | `typescript-eslint`               |
+| Next.js                   | `.jsx` `.tsx`     | `typescript-eslint`               |
+| Vue, Nuxt                 | `.vue`            | `vue-eslint-parser`               |
+| Svelte, SvelteKit         | `.svelte`         | `svelte-eslint-parser`            |
+| Angular                   | `.ts`             | `typescript-eslint`               |
+| Šablony Angularu          | `.component.html` | `@angular-eslint/template-parser` |
+| Astro                     | `.astro`          | `astro-eslint-parser`             |
+
+```javascript fileName="eslint.config.mjs"
+import intlayer from "eslint-plugin-intlayer";
+import tseslint from "typescript-eslint";
+import vueParser from "vue-eslint-parser";
+import svelteParser from "svelte-eslint-parser";
+import angularTemplateParser from "@angular-eslint/template-parser";
+
+export default [
+  ...intlayer.configs.recommended,
+
+  {
+    files: ["**/*.{ts,tsx,jsx}"],
+    languageOptions: { parser: tseslint.parser },
+  },
+  {
+    files: ["**/*.vue"],
+    languageOptions: {
+      parser: vueParser,
+      parserOptions: { parser: tseslint.parser },
+    },
+  },
+  {
+    files: ["**/*.svelte"],
+    languageOptions: {
+      parser: svelteParser,
+      parserOptions: { parser: tseslint.parser },
+    },
+  },
+  {
+    files: ["**/*.component.html"],
+    languageOptions: { parser: angularTemplateParser },
+  },
+];
+```
+
+Nainstalujte pouze ty parsery, které váš projekt vyžaduje.
+
+> **Známé omezení.** V šablonách Vue a Angularu výraz jako `{{ content[key] }}` není kontrolován pravidlem `no-dynamic-field-access`. Dynamická čtení zapsaná ve skriptovém bloku jsou zachycena normálně.

package/docs/de/bundle_optimization.md

@@ -159,7 +159,7 @@ pnpm add -D webpack-bundle-analyzer
 bun add -d webpack-bundle-analyzer
 ```
 
-```typescript fileName="webpack.config.ts
+```typescript fileName="webpack.config.ts"
 import { BundleAnalyzerPlugin } from "webpack-bundle-analyzer";
 
 export default {

package/docs/de/configuration.md

@@ -478,6 +478,29 @@ const config: IntlayerConfig = {
      */
     purge: true,
 
+    /**
+     * Die locale-spezifischen Wörterbuch-Chunks nach der Code-Splitting-Grenze
+     * gruppieren, die sie verwendet, damit eine verzögert geladene Seite ihren
+     * Inhalt in einer Anfrage abruft.
+     * Standard: true
+     *
+     * Hinweis:
+     * - Gilt nur für Wörterbücher mit `importMode: 'dynamic'`.
+     */
+    chunkGrouping: true,
+
+    /**
+     * Ein Wörterbuch zusammen mit dem Chunk laden, der es verwendet, statt es
+     * abzurufen, sobald dieser Chunk rendert. Leser rendern synchron statt zu
+     * suspendieren, sodass beim Navigieren kein Ladezustand mehr aufblitzt.
+     * Standard: true
+     *
+     * Hinweis:
+     * - Es wird nur die aufgelöste Locale abgewartet, die Seite lädt also
+     *   weiterhin nur die Sprache, die sie darstellt.
+     */
+    dictionariesPreload: true,
+
     /**
      * Ausgabeformat für generierte Wörterbuchdateien.
      * Standard: ['cjs', 'esm']
@@ -1057,15 +1080,17 @@ Die Build-Optionen gelten für die Plugins `@intlayer/babel` und `@intlayer/swc`
 
 > Bei der Optimierung ersetzt Intlayer Wörterbuch-Aufrufe, um das Chunking zu optimieren, sodass das finale Bundle nur die tatsächlich verwendeten Wörterbücher importiert.
 
-| Feld              | Beschreibung                                                                              | Typ                              | Standard                                                                                                                                                                          | Beispiel                                                                      | Hinweis                                                                                                                                                                                                                                                                                                                           |
-| ----------------- | ----------------------------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mode`            | Steuert den Build-Modus.                                                                  | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: Build wird automatisch während des App-Builds ausgelöst.<br/>• `'manual'`: Wird nur ausgeführt, wenn der Build-Befehl explizit aufgerufen wird.<br/>• Kann verwendet werden, um Wörterbuch-Builds zu deaktivieren (z. B. um die Ausführung in Node.js-Umgebungen zu vermeiden).                                       |
-| `optimize`        | Steuert, ob der Build optimiert werden soll.                                              | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • Wenn nicht definiert, wird die Optimierung beim Build des Frameworks (Vite/Next.js) ausgelöst.<br/>• `true` erzwingt die Optimierung auch im Dev-Modus.<br/>• `false` deaktiviert sie.<br/>• Wenn aktiv, ersetzt es Wörterbuch-Aufrufe zur Chunking-Optimierung.<br/>• Erfordert `@intlayer/babel` und `@intlayer/swc` Plugins. |
-| `minify`          | Dictionarien minimieren, um die Bundle-Größe zu reduzieren.                               | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Gibt an, ob das Bundle minimiert werden soll.<br/>• Standard: `true` in Produktion.<br/>• Diese Option wird ignoriert, wenn `optimize` deaktiviert ist.<br/>• Diese Option wird ignoriert, wenn `editor.enabled` auf true gesetzt ist.                                                                                          |
-| `purge`           | Nicht verwendete Schlüssel in Dictionarien entfernen.                                     | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Gibt an, ob das Bundle bereinigt werden soll.<br/>• Standard: `true` in Produktion.<br/>• Diese Option wird ignoriert, wenn `optimize` deaktiviert ist.                                                                                                                                                                         |
-| `checkTypes`      | Gibt an, ob der Build TypeScript-Typen prüfen und Fehler protokollieren soll.             | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | Kann den Build-Prozess verlangsamen.                                                                                                                                                                                                                                                                                              |
-| `outputFormat`    | Steuert das Ausgabeformat der Wörterbücher.                                               | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                                   |
-| `traversePattern` | Muster, die definieren, welche Dateien während der Optimierung durchlaufen werden sollen. | `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/**']` | • Begrenzen Sie die Optimierung auf relevante Dateien, um die Build-Leistung zu verbessern.<br/>• Wird ignoriert, wenn `optimize` deaktiviert ist.<br/>• Verwendet Glob-Muster.                                                                                                                                                   |
+| Feld                  | Beschreibung                                                                                                                                     | Typ                              | Standard                                                                                                                                                                          | Beispiel                                                                      | Hinweis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mode`                | Steuert den Build-Modus.                                                                                                                         | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: Build wird automatisch während des App-Builds ausgelöst.<br/>• `'manual'`: Wird nur ausgeführt, wenn der Build-Befehl explizit aufgerufen wird.<br/>• Kann verwendet werden, um Wörterbuch-Builds zu deaktivieren (z. B. um die Ausführung in Node.js-Umgebungen zu vermeiden).                                                                                                                                                                                                                                                                       |
+| `optimize`            | Steuert, ob der Build optimiert werden soll.                                                                                                     | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • Wenn nicht definiert, wird die Optimierung beim Build des Frameworks (Vite/Next.js) ausgelöst.<br/>• `true` erzwingt die Optimierung auch im Dev-Modus.<br/>• `false` deaktiviert sie.<br/>• Wenn aktiv, ersetzt es Wörterbuch-Aufrufe zur Chunking-Optimierung.<br/>• Erfordert `@intlayer/babel` und `@intlayer/swc` Plugins.                                                                                                                                                                                                                                 |
+| `minify`              | Dictionarien minimieren, um die Bundle-Größe zu reduzieren.                                                                                      | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Gibt an, ob das Bundle minimiert werden soll.<br/>• Standard: `true` in Produktion.<br/>• Diese Option wird ignoriert, wenn `optimize` deaktiviert ist.<br/>• Diese Option wird ignoriert, wenn `editor.enabled` auf true gesetzt ist.                                                                                                                                                                                                                                                                                                                          |
+| `purge`               | Nicht verwendete Schlüssel in Dictionarien entfernen.                                                                                            | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Gibt an, ob das Bundle bereinigt werden soll.<br/>• Standard: `true` in Produktion.<br/>• Diese Option wird ignoriert, wenn `optimize` deaktiviert ist.                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `checkTypes`          | Gibt an, ob der Build TypeScript-Typen prüfen und Fehler protokollieren soll.                                                                    | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | Kann den Build-Prozess verlangsamen.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `chunkGrouping`       | Gibt an, ob die locale-spezifischen Wörterbuch-Chunks nach der Code-Splitting-Grenze gruppiert werden sollen, die sie verwendet.                 | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • Ohne Gruppierung stellt eine aus vielen Komponenten zusammengesetzte Seite eine Anfrage pro Wörterbuch.<br/>• Wörterbücher, die von mehreren Grenzen erreicht werden, wandern in einen gemeinsamen Chunk, sodass keine Seite den Inhalt einer anderen ausliefert.<br/>• Gilt nur für Wörterbücher mit `importMode: 'dynamic'`.<br/>• Gilt nur für den Client-Build und nur beim Bundling (nicht im Dev-Modus).                                                                                                                                                  |
+| `dictionariesPreload` | Gibt an, ob ein Wörterbuch zusammen mit dem Chunk geladen werden soll, der es verwendet, statt abgerufen zu werden, sobald dieser Chunk rendert. | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • Der generierte Einstiegspunkt wartet die Browsing-Locale auf oberster Ebene ab, sodass eine verzögert geladene Route erst als geladen gilt, wenn ihr Inhalt vorliegt.<br/>• Leser rendern synchron statt zu suspendieren, sodass beim Navigieren kein Ladezustand mehr aufblitzt.<br/>• Es wird nur die aufgelöste Locale abgewartet, die Seite lädt also nur die Sprache, die sie darstellt.<br/>• Gilt nur für Wörterbücher mit `importMode: 'dynamic'` im Client-Build.<br/>• Erfordert einen Bundler mit Unterstützung für Top-Level-Await (Vite, esbuild). |
+| `outputFormat`        | Steuert das Ausgabeformat der Wörterbücher.                                                                                                      | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `traversePattern`     | Muster, die definieren, welche Dateien während der Optimierung durchlaufen werden sollen.                                                        | `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/**']` | • Begrenzen Sie die Optimierung auf relevante Dateien, um die Build-Leistung zu verbessern.<br/>• Wird ignoriert, wenn `optimize` deaktiviert ist.<br/>• Verwendet Glob-Muster.                                                                                                                                                                                                                                                                                                                                                                                   |
 
 ---
 

package/docs/de/dictionary/content_file.md

@@ -536,28 +536,6 @@ Dieses Feld wird in Verbindung mit Varianten verwendet und definiert benannte In
 
 > Siehe [Varianten](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/variants.md) für weitere Informationen.
 
-#### `meta` (`Record<string, string | number | boolean>`)
-
-Dieses Feld wird in Verbindung mit dynamischen Datensätzen (Dynamic Records) verwendet und ermöglicht die Deklaration von CMS-verwalteten Datensätzen oder beliebigen Daten, die zur Laufzeit über eine opake ID abgerufen werden. Die Wörterbuchidentität wird durch die beliebige Menge von Schlüssel-Wert-Paaren definiert, die in diesem `meta`-Feld deklariert sind.
-
-**Beispiel:**
-
-```typescript
-{
-  key: "product-copy",
-  meta: {
-    id: "prod_abc",
-    userId: "user_123"
-  },
-  content: {
-    name: "Widget Pro",
-    description: "The best widget."
-  }
-}
-```
-
-> Siehe [Dynamische Datensätze](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/dynamic_content.md) für weitere Informationen.
-
 ### CMS-Eigenschaften
 
 ##### `version` (string)

package/docs/de/dictionary/function_fetching.md

@@ -89,6 +89,29 @@ Es ist nicht möglich, Inhalte aus einer JSON-Datei abzurufen, verwenden Sie sta
 
 In diesem Fall simuliert die Funktion `fakeFetch` eine Verzögerung, um die Serverantwortzeit nachzuahmen. Intlayer führt die asynchrone Funktion aus und verwendet das Ergebnis als Inhalt für den Schlüssel `text`.
 
+## Remote-Inhalte abrufen
+
+Sie können einem Inhaltsfeld auch direkt ein Promise zuweisen. Intlayer wartet es beim Erstellen der Wörterbücher ab und fügt den aufgelösten Wert ein:
+
+```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"
+Es ist nicht möglich, Inhalte aus einer JSON-Datei abzurufen, verwenden Sie stattdessen eine .ts- oder .js-Datei
+```
+
+> Die Anfrage wird zur Build-Zeit ausgeführt, die abgerufenen Daten sind also eine im Wörterbuch eingebettete Momentaufnahme. Erstellen Sie Ihre Wörterbücher neu, um sie zu aktualisieren.
+
 ## Verwendung von funktionsbasierten Inhalten in React-Komponenten
 
 Um funktionsbasierte Inhalte in einer React-Komponente zu verwenden, müssen Sie `useIntlayer` aus `react-intlayer` importieren und mit der Inhalts-ID aufrufen, um den Inhalt abzurufen. Hier ist ein Beispiel: