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

package/docs/de/migration_from_next-i18next_to_intlayer.md

@@ -19,7 +19,7 @@ slugs:
   - migration
   - next-i18next
 history:
-  - version: 8.13.0
+  - version: 9.0.0
     date: 2026-06-05
     changes: "Init history"
 author: aymericzip

package/docs/de/migration_from_next-intl_to_intlayer.md

@@ -17,7 +17,7 @@ slugs:
   - migration
   - next-intl
 history:
-  - version: 8.13.0
+  - version: 9.0.0
     date: 2026-06-05
     changes: "Init history"
 author: aymericzip

package/docs/de/migration_from_nuxtjs_i18n_to_intlayer.md

@@ -18,7 +18,7 @@ slugs:
   - migration
   - nuxtjs-i18n
 history:
-  - version: 8.13.0
+  - version: 9.0.0
     date: 2026-06-05
     changes: "Init history"
 author: aymericzip

package/docs/de/migration_from_react-i18next_to_intlayer.md

@@ -18,7 +18,7 @@ slugs:
   - migration
   - react-i18next
 history:
-  - version: 8.13.0
+  - version: 9.0.0
     date: 2026-06-05
     changes: "Init history"
 author: aymericzip

package/docs/de/migration_from_vue-i18n_to_intlayer.md

@@ -17,7 +17,7 @@ slugs:
   - migration
   - vue-i18n
 history:
-  - version: 8.13.0
+  - version: 9.0.0
     date: 2026-06-05
     changes: "Init history"
 author: aymericzip

package/docs/de/plugins/sync-json.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-03-13
-updatedAt: 2025-12-13
+updatedAt: 2026-06-21
 title: Sync JSON Plugin
 description: Synchronisieren Sie Intlayer-Wörterbücher mit Drittanbieter-i18n-JSON-Dateien (i18next, next-intl, react-intl, vue-i18n und mehr). Behalten Sie Ihr bestehendes i18n bei und verwenden Sie Intlayer, um Ihre Nachrichten zu verwalten, zu übersetzen und zu testen.
 keywords:
@@ -24,6 +24,9 @@ slugs:
   - sync-json
 youtubeVideo: https://www.youtube.com/watch?v=MpGMxniDHNg
 history:
+  - version: 9.0.0
+    date: 2026-06-21
+    changes: "Option `splitKeys` hinzugefügt (ein Wörterbuch pro Top-Level-Namespace-Schlüssel) für next-intl / react-intl Single-File-Layouts"
   - version: 7.5.0
     date: 2025-12-13
     changes: "Unterstützung für ICU- und i18next-Formate hinzugefügt"
@@ -62,7 +65,63 @@ pnpm add -D @intlayer/sync-json-plugin
 npm i -D @intlayer/sync-json-plugin
 ```
 
-## Schnellstart
+## Plugins
+
+Dieses Paket bietet zwei Plugins:
+
+- `loadJSON`: Lädt JSON-Dateien in Intlayer-Wörterbücher.
+  - Dieses Plugin wird verwendet, um JSON-Dateien aus einer Quelle zu laden, und diese werden in Intlayer-Wörterbücher geladen. Es kann die gesamte Codebasis durchsuchen und nach bestimmten JSON-Dateien suchen.
+    Dieses Plugin kann verwendet werden
+    - wenn Sie eine i18n-Bibliothek verwenden, die einen bestimmten Speicherort für Ihre zu ladenden JSON-Dateien vorschreibt (z.B. `next-intl`, `i18next`, `react-intl`, `vue-i18n` usw.), Sie aber Ihre Inhaltsdeklaration an einer beliebigen Stelle in Ihrer Codebasis platzieren möchten.
+    - Es kann auch verwendet werden, wenn Sie Ihre Nachrichten von einer Remote-Quelle (z.B. einem CMS, einer API usw.) abrufen und Ihre Nachrichten in JSON-Dateien speichern möchten.
+
+  > Im Hintergrund scannt dieses Plugin die gesamte Codebasis, sucht nach bestimmten JSON-Dateien und lädt sie in Intlayer-Wörterbücher.
+  > Beachten Sie, dass dieses Plugin die Ausgabe und Übersetzungen nicht zurück in die JSON-Dateien schreibt.
+
+- `syncJSON`: Synchronisiert JSON-Dateien mit Intlayer-Wörterbüchern.
+  - Dieses Plugin wird verwendet, um JSON-Dateien mit Intlayer-Wörterbüchern zu synchronisieren. Es kann den angegebenen Speicherort scannen und die JSON-Dateien laden, die dem Muster für bestimmte JSON-Dateien entsprechen. Dieses Plugin ist nützlich, wenn Sie die Vorteile von Intlayer nutzen möchten, während Sie eine andere i18n-Bibliothek verwenden.
+
+## Beide Plugins verwenden
+
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON, syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  // Halten Sie Ihre aktuellen JSON-Dateien mit den Intlayer-Wörterbüchern synchron
+  plugins: [
+    /**
+     * Lädt alle JSON-Dateien im src-Verzeichnis, die dem Muster {key}.i18n.json entsprechen
+     */
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      locale: Locales.ENGLISH,
+      priority: 1, // Stellt sicher, dass diese JSON-Dateien Vorrang vor Dateien unter `./locales/en/${key}.json` haben
+      format: "intlayer", // Format des JSON-Inhalts
+    }),
+    /**
+     * Lädt die Ausgabe und Übersetzungen und schreibt sie zurück in die JSON-Dateien im locales-Verzeichnis
+     */
+    syncJSON({
+      format: "i18next",
+      source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      priority: 0,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
+```
+
+## `syncJSON` plugin
+
+### Schnellstart
 
 Fügen Sie das Plugin zu Ihrer `intlayer.config.ts` hinzu und verweisen Sie auf Ihre bestehende JSON-Struktur.
 
@@ -81,6 +140,7 @@ const config: IntlayerConfig = {
     syncJSON({
       // Pro-Locale, pro-Namespace Layout (z.B. next-intl, i18next mit Namespaces)
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      format: "icu",
     }),
   ],
 };
@@ -91,14 +151,27 @@ export default config;
 Alternative: Einzelne Datei pro Locale (häufig bei i18next/react-intl Setups):
 
 ```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+import { Locales, type IntlayerConfig } from "intlayer";
+import { syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  plugins: [
+    syncJSON({
+      format: "i18next",
+      source: ({ locale }) => `./locales/${locale}.json`,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
 ```
 
-### Funktionsweise
+#### Funktionsweise
 
 - Lesen: Das Plugin entdeckt JSON-Dateien über Ihren `source`-Builder und lädt sie als Intlayer-Wörterbücher.
 - Schreiben: Nach dem Build und Ausfüllen schreibt es die lokalisierten JSON-Dateien zurück an dieselben Pfade (mit einer abschließenden neuen Zeile, um Formatierungsprobleme zu vermeiden).
@@ -112,6 +185,7 @@ syncJSON({
   location?: string, // optionales Label, Standard: "plugin"
   priority?: number, // optionale Priorität zur Konfliktlösung, Standard: 0
   format?: 'intlayer' | 'icu' | 'i18next', // optionaler Formatierer, verwendet für Intlayer-Runtime-Kompatibilität
+  splitKeys?: boolean, // optional, teilt eine einzelne Datei in ein Wörterbuch pro Top-Level-Schlüssel (automatisch erkannt)
 });
 ```
 
@@ -136,17 +210,49 @@ syncJSON({
 }),
 ```
 
-## Mehrere JSON-Quellen und Priorität
+#### `splitKeys` (boolean)
+
+Steuert, ob eine einzelne JSON-Datei, deren **Top-Level-Schlüssel Namespaces sind**, zu einem Wörterbuch pro Top-Level-Schlüssel werden soll, anstatt eines einzelnen Wörterbuchs, das die gesamte Datei enthält.
+
+Dies entspricht dem Namespace-Modell von Bibliotheken wie `next-intl` und `react-intl`, bei denen eine `messages/{locale}.json`-Datei mehrere Namespaces durch ihre Top-Level-Schlüssel gruppiert, wobei jeder unabhängig angesprochen wird (z.B. `useTranslations('Hero')` löst sich in das `Hero`-Wörterbuch auf).
+
+- `undefined` (Standard): **automatisch erkannt** — die Datei wird aufgeteilt, wenn das `source`-Muster kein `{key}`-Segment enthält (eine Datei enthält jeden Namespace), und andernfalls als einzelnes Wörterbuch beibehalten (eine Datei pro Schlüssel).
+- `true`: teilt jeden Top-Level-Schlüssel immer in ein eigenes Wörterbuch auf.
+- `false`: niemals aufteilen; die gesamte Datei wird zu einem einzigen Wörterbuch.
+
+Angenommen, eine einzelne `messages/{locale}.json`-Datei:
+
+```json fileName="messages/en.json"
+{
+  "Hero": { "title": "Full-stack developer" },
+  "Nav": { "work": "Work", "about": "About" },
+  "About": { "lead": "I build apps end to end." }
+}
+```
+
+```ts fileName="intlayer.config.ts"
+syncJSON({
+  format: "icu",
+  source: ({ locale }) => `./messages/${locale}.json`,
+  // splitKeys: true, // impliziert, da das Muster kein `{key}`-Segment enthält
+}),
+```
+
+Dies erzeugt drei Wörterbücher — `Hero`, `Nav` und `About` — sodass `useTranslations('Hero')` (next-intl) korrekt aufgelöst wird. Beim Zurückschreiben werden alle Namespaces wieder in derselben pro-Locale-Datei zusammengeführt.
+
+> Wenn Sie das explizite `{key}`-Segment in Ihrer `source` beibehalten (z.B. `./locales/${locale}/${key}.json`), ist jede Datei bereits ein Namespace, sodass die Aufteilung standardmäßig deaktiviert ist.
+
+### Mehrere JSON-Quellen und Priorität
 
 Sie können mehrere `syncJSON`-Plugins hinzufügen, um verschiedene JSON-Quellen zu synchronisieren. Dies ist nützlich, wenn Sie mehrere i18n-Bibliotheken oder unterschiedliche JSON-Strukturen in Ihrem Projekt haben.
 
-### Prioritätssystem
+#### Prioritätssystem
 
 Wenn mehrere Plugins denselben Wörterbuchschlüssel ansprechen, bestimmt der Parameter `priority`, welches Plugin Vorrang hat:
 
 - Höhere Prioritätszahlen haben Vorrang vor niedrigeren
 - Die Standardpriorität von `.content`-Dateien ist `0`
-- Die Standardpriorität von Plugin-Content-Dateien ist `-1`
+- Die Standardpriorität von Plugins ist `0`
 - Plugins mit derselben Priorität werden in der Reihenfolge verarbeitet, in der sie in der Konfiguration erscheinen
 
 ```ts fileName="intlayer.config.ts"
@@ -189,73 +295,140 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-### Konfliktlösung
+## Load JSON Plugin
 
-Wenn derselbe Übersetzungsschlüssel in mehreren JSON-Quellen vorhanden ist:
+### Schnellstart
 
-1. Bestimmt das Plugin mit der höchsten Priorität den endgültigen Wert
-2. Werden Quellen mit niedrigerer Priorität als Fallbacks für fehlende Schlüssel verwendet
-3. Ermöglicht es Ihnen, Legacy-Übersetzungen beizubehalten und gleichzeitig schrittweise auf neue Strukturen umzusteigen
+Fügen Sie das Plugin zu Ihrer `intlayer.config.ts` hinzu, um vorhandene JSON-Dateien als Intlayer-Wörterbücher zu importieren. Dieses Plugin ist schreibgeschützt (keine Schreibvorgänge auf die Festplatte):
 
-## Integrationen
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-Nachfolgend sind gängige Zuordnungen aufgeführt. Belassen Sie Ihre Laufzeit unverändert; fügen Sie nur das Plugin hinzu.
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
 
-### i18next
+  plugins: [
+    // Importiert JSON-Nachrichten, die sich überall in Ihrem Quellbaum befinden
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      // Lädt eine einzelne Locale pro Plugin-Instanz (standardmäßig die Standard-Locale der Konfiguration)
+      locale: Locales.ENGLISH,
+      priority: 0,
+    }),
+  ],
+};
 
-Typische Dateistruktur: `./public/locales/{locale}/{namespace}.json` oder `./locales/{locale}/{namespace}.json`.
+export default config;
+```
+
+Alternative: Pro-Locale-Layout, weiterhin schreibgeschützt (nur die ausgewählte Locale wird geladen):
 
 ```ts fileName="intlayer.config.ts"
-import { syncJSON } from "@intlayer/sync-json-plugin";
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-export default {
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
   plugins: [
-    syncJSON({
-      format: "i18next",
+    loadJSON({
+      // Nur Dateien für Locales.FRENCH werden aus diesem Muster geladen
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      locale: Locales.FRENCH,
     }),
   ],
 };
+
+export default config;
 ```
 
-### next-intl
+### Funktionsweise
 
-JSON-Nachrichten pro Locale (oft `./messages/{locale}.json`) oder pro Namespace.
+- Entdecken: Erstellt einen Glob aus Ihrem `source`-Builder und sammelt passende JSON-Dateien.
+- Importieren: Lädt jede JSON-Datei als Intlayer-Wörterbuch mit der angegebenen `locale`.
+- Schreibgeschützt: Schreibt oder formatiert keine Ausgabedateien; verwenden Sie `syncJSON`, wenn Sie eine Roundtrip-Synchronisierung benötigen.
+- Auto-Fill bereit: Definiert ein `fill`-Muster, sodass `intlayer content fill` fehlende Schlüssel füllen kann.
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale, key }) => `./messages/${locale}/${key}.json`,
-  }),
-];
+### API
+
+```ts
+loadJSON({
+  // Erstellt Pfade zu Ihren JSON-Dateien. `locale` ist optional, wenn Ihre Struktur kein Locale-Segment hat
+  source: ({ key, locale }) => string,
+
+  // Ziel-Locale für die von dieser Plugin-Instanz geladenen Wörterbücher
+  // Standardmäßig configuration.internationalization.defaultLocale
+  locale?: Locale,
+
+  // Optionales Label zur Identifizierung der Quelle
+  location?: string, // Standard: "plugin"
+
+  // Priorität zur Konfliktlösung gegenüber anderen Quellen
+  priority?: number, // Standard: 0
+
+  // Optionaler Formatierer für den JSON-Inhalt
+  format?: 'intlayer' | 'icu' | 'i18next', // Standard: 'intlayer'
+
+  // Teilt eine einzelne Datei in ein Wörterbuch pro Top-Level-Schlüssel (automatisch erkannt)
+  splitKeys?: boolean,
+});
 ```
 
-Siehe auch: `docs/de/intlayer_with_next-intl.md`.
+#### `format` ('intlayer' | 'icu' | 'i18next')
 
-### react-intl
+Gibt den Formatierer an, der für den Wörterbuchinhalt beim Laden von JSON-Dateien verwendet werden soll. Dies ermöglicht die Verwendung verschiedener Nachrichtenformatierungssyntaxen, die mit verschiedenen i18n-Bibliotheken kompatibel sind.
 
-Einzelne JSON-Datei pro Locale ist üblich:
+- `'intlayer'`: Der Standard-Intlayer-Formatierer (Standard).
+- `'icu'`: Verwendet ICU-Nachrichtenformatierung (kompatibel mit Bibliotheken wie react-intl, vue-i18n).
+- `'i18next'`: Verwendet i18next-Nachrichtenformatierung (kompatibel mit i18next, next-i18next, Solid-i18next).
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+**Beispiel:**
+
+```ts
+loadJSON({
+  source: ({ key }) => `./src/**/${key}.i18n.json`,
+  locale: Locales.ENGLISH,
+  format: "icu", // ICU-Formatierung für Kompatibilität verwenden
+}),
 ```
 
-### vue-i18n
+#### `splitKeys` (boolean)
 
-Entweder eine einzelne Datei pro Locale oder pro Namespace:
+Gleiches Verhalten wie bei [`syncJSON`](#splitkeys-boolean): Wenn eine einzelne JSON-Datei mehrere Namespaces durch ihre Top-Level-Schlüssel gruppiert, wird jeder Top-Level-Schlüssel zu einem eigenen Wörterbuch.
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ key, locale }) => `./src/locales/${locale}/${key}.json`,
-  }),
-];
+- `undefined` (Standard): **automatisch erkannt** — Aufteilung, wenn das `source`-Muster kein `{key}`-Segment enthält, andernfalls ein einzelnes Wörterbuch.
+- `true` / `false`: Aufteilung erzwingen oder deaktivieren.
+
+```ts
+loadJSON({
+  source: ({ locale }) => `./messages/${locale}.json`,
+  format: "icu",
+  // splitKeys automatisch aktiviert: `Hero`, `Nav`, `About`, … jeder wird zu einem Wörterbuch
+}),
 ```
 
+### Verhalten und Konventionen
+
+- Wenn Ihre `source`-Maske einen Locale-Platzhalter enthält, werden nur Dateien für die ausgewählte `locale` importiert.
+- Wenn in Ihrer Maske kein `{key}`-Segment vorhanden ist, wird jeder Top-Level-Schlüssel der Datei standardmäßig zu einem eigenen Wörterbuch (siehe [`splitKeys`](#splitkeys-boolean)). Setzen Sie `splitKeys: false`, um stattdessen die gesamte Datei als ein einziges `index`-Wörterbuch zu laden.
+- Schlüssel werden aus Dateipfaden abgeleitet, indem der `{key}`-Platzhalter in Ihrem `source`-Builder ersetzt wird.
+- Das Plugin verwendet nur entdeckte Dateien und erstellt keine fehlenden Locales oder Schlüssel.
+- Der `fill`-Pfad wird aus Ihrer `source` abgeleitet und verwendet, um fehlende Werte über die CLI zu aktualisieren, wenn Sie sich dafür entscheiden.
+
+## Konfliktlösung
+
+Wenn derselbe Übersetzungsschlüssel in mehreren JSON-Quellen vorhanden ist:
+
+1. Bestimmt das Plugin mit der höchsten Priorität den endgültigen Wert
+2. Werden Quellen mit niedrigerer Priorität als Fallbacks für fehlende Schlüssel verwendet
+3. Ermöglicht es Ihnen, Legacy-Übersetzungen beizubehalten und gleichzeitig schrittweise auf neue Strukturen umzusteigen
+
 ## CLI
 
 Die synchronisierten JSON-Dateien werden wie andere `.content`-Dateien behandelt. Das bedeutet, dass alle intlayer-Befehle für die synchronisierten JSON-Dateien verfügbar sind. Einschließlich:

package/docs/de/releases/v8.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-22
-updatedAt: 2026-01-26
+updatedAt: 2026-06-14
 title: Neues Intlayer v8 - Was ist neu?
 description: Entdecken Sie die Neuerungen in Intlayer v8. Bedeutende Verbesserungen in der Developer Experience, der Inhaltsvalidierung und der Verwaltung von Dictionaries.
 keywords:
@@ -409,6 +409,16 @@ Weitere Einzelheiten finden Sie in der [Dokumentation zu HTML-Inhalten](https://
 
 ---
 
+## YAML- & Markdown-Inhaltsdateien (v8.10.0)
+
+Sie können Inhalte jetzt direkt mit den Dateierweiterungen `.content.md` und `.content.yaml` deklarieren. Dies ist perfekt für Langform-Inhalte, Blogs, Dokumentationen und Datenschutzrichtlinien.
+
+Diese Dateien sind vollständig über den Visual Editor bearbeitbar und bieten einen optimierten Workflow für nicht-technische Teammitglieder.
+
+Weitere Details finden Sie in der [Dokumentation zu YAML-Inhaltsdateien](https://intlayer.org/doc/concept/content#yaml-content-file) und der [Dokumentation zu Markdown-Inhaltsdateien](https://intlayer.org/doc/concept/content/markdown).
+
+---
+
 ## Benutzerdefinierte URL-Umschreibungen (Rewrites)
 
 Intlayer v8 führt Unterstützung für **benutzerdefinierte URL-Umschreibungen** ein, mit denen Sie locale-spezifische Pfade definieren können, die von der Standardstruktur `/locale/path` abweichen. Dies ist eine leistungsstarke Funktion zur Verbesserung der lokalen SEO und bietet eine natürlichere Benutzererfahrung für nicht-englischsprachige Nutzer.
@@ -753,6 +763,68 @@ export default {
   </Tab>
 </Tabs>
 
+## Unicode CLDR Pluralregeln (v8.8.0)
+
+Ein neuer `plural` Node-Helper wurde basierend auf den Pluralregeln des Unicode CLDR Projekts eingeführt, um die Unterstützung für komplexe Sprachen zu verbessern.
+
+```typescript fileName="src/openings.content.ts"
+import { plural, t, type Dictionary } from "intlayer";
+
+const openingsContent = {
+  key: "total_openings",
+  content: {
+    totalOpenings: t({
+      en: plural({
+        one: "{{count}} opening",
+        other: "{{count}} openings",
+      }),
+      fr: plural({
+        one: "{{count}} offre",
+        other: "{{count}} offres",
+      }),
+      de: plural({
+        // Added German translation for plural example
+        one: "{{count}} offene Stelle",
+        other: "{{count}} offene Stellen",
+      }),
+    }),
+  },
+} satisfies Dictionary;
+
+export default openingsContent;
+```
+
+Sie können den Zähler dann dynamisch in Ihrer Framework-Komponente übergeben:
+
+```tsx
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const OpeningsComponent: FC<{ count: number }> = ({ count }) => {
+  const { totalOpenings } = useIntlayer("total_openings");
+
+  return (
+    <div>
+      {/* In English:                                  */}
+      {/*  count=0  → "0 openings"   (other)           */}
+      {/*  count=1  → "1 opening"    (one)             */}
+      {/*  count=2  → "2 openings"   (other)           */}
+      {/*  count=21 → "21 openings"  (other)           */}
+      {/* In German:                                   */}
+      {/*  count=0  → "0 offene Stellen" (other)       */}
+      {/*  count=1  → "1 offene Stelle"  (one)         */}
+      {/*  count=2  → "2 offene Stellen" (other)       */}
+      {/*  count=21 → "21 offene Stellen" (other)      */}
+      <p>{totalOpenings(count)}</p>
+    </div>
+  );
+};
+```
+
+Weitere Informationen finden Sie in der [Dokumentation zur Pluralisierung](https://intlayer.org/doc/concept/content/plural).
+
+---
+
 ## Inhalts-Schema-Validierung
 
 Intlayer v8 führt die Schema-Validierung für Dictionaries ein. Sie können jetzt wiederverwendbare Validierungsschemata in Ihrer Konfiguration mit Zod definieren und auf Ihre Inhaltsdateien anwenden. Dies stellt sicher, dass Ihr Inhalt immer der erwarteten Struktur entspricht, und fängt Fehler bereits zur Build-Zeit ab.
@@ -798,6 +870,34 @@ Wenn der Inhalt nicht mit dem Schema übereinstimmt (z. B. der Titel zu kurz ist
 
 ---
 
+## TypeScript: IntlayerNode Primitive Accessors
+
+Der `IntlayerNode`-Typ wurde aktualisiert, um das direkte Aufrufen primitiver JavaScript-Methoden auf Inhaltsknoten zu ermöglichen. Dies macht es möglich, mit Ihren lokalisierten Inhalten direkt zu interagieren, als wären sie ein Standard-String-, Zahlen-, Boolean- oder Array-Primitiv.
+
+Unterstützt in React, Preact, Solid, Svelte, Vue und Angular.
+
+### String-Beispiel
+
+```typescript
+content.placeholder; // Gibt IntlayerNode<string> zurück
+content.placeholder.value; // Gibt string zurück
+content.placeholder.toString(); // Gibt string zurück
+content.placeholder.toLowerCase(); // Gibt string zurück
+String(content.placeholder); // Gibt string zurück
+content.placeholder.toUpperCase(); // Gibt großgeschriebenen string zurück
+content.placeholder.replace("a", "b"); // Gibt modifizierten string zurück
+```
+
+### Array-Beispiel
+
+```typescript
+content.myArrayOfString             // Gibt IntlayerNode<Array<string>> zurück
+content.myArrayOfString.find(...)   // Gibt Element zurück
+content.myArrayOfString.join(', ')  // Gibt verbundenen string zurück
+```
+
+---
+
 ### Verbesserte automatische Inhaltserkennung
 
 In v8 erkennt Intlayer intelligent Markdown-Syntax, HTML-Tags und Variablen-Insertions in Ihren Inhaltsstrings. Das bedeutet, dass Sie häufig auf Hilfsfunktionen wie `md()`, `html()` oder `insert()` verzichten können.
@@ -1003,6 +1103,17 @@ Die Intlayer VSCode-Extension erhält in v8 bedeutende Updates, um Ihren Interna
 
 ---
 
+## Tooling: C++ Watcher & OXC-basierter LSP (v8.12.0)
+
+Intlayer v8.12.0 bringt wesentliche Verbesserungen für die Developer Experience:
+
+- **Parcel Watcher**: Der Content Watcher wurde von `chokidar` zu `@parcel/watcher` migriert, wodurch natives C++ File Watching genutzt wird, um schnellere Updates und einen deutlich geringeren Speicherverbrauch zu ermöglichen.
+- **Neues Language Server Protocol (LSP)**: Ein brandneues LSP ist jetzt verfügbar. Basierend auf OXC-Parsing hilft es Ihrer IDE und Ihren AI-Agenten, `useIntlayer('my-key')`-Aufrufe nahtlos mit den entsprechenden `.content`-Dateien zu verknüpfen und umgekehrt.
+
+Weitere Details finden Sie in der [LSP-Dokumentation](https://intlayer.org/doc/lsp).
+
+---
+
 ## Compiler-Optimierungen
 
 Intlayer v8 enthält eine neue Caching-Schicht für den Markdown- und HTML-Compiler. Dies stellt sicher, dass identische Inhaltsstrings mit derselben Konfiguration nur einmal geparst werden, was den Overhead bei Re-Renderings oder bei der Verwendung desselben Inhalts an mehreren Stellen erheblich reduziert.
@@ -1058,6 +1169,48 @@ Intlayer v8 enthält eine neue Caching-Schicht für den Markdown- und HTML-Compi
 
 ---
 
+## Experimentelle Build-Optimierungen: Minify & Purge (v8.7.0)
+
+Intlayer v8.7.0 führt neue experimentelle Build-Funktionen in Ihrer `intlayer.config.ts` ein, die darauf abzielen, Ihr Produktions-Bundle zu optimieren:
+
+- **Dictionary Minification**: Minifiziert Dictionary-Dateien, um die Größe zu reduzieren.
+- **Unused Key Purging**: Scannt und entfernt ungenutzte Übersetzungsschlüssel aus Dictionaries und benennt aktive Schlüssel in kurze Zeichen um (z. B. `"products" -> "a"`, `"pricing" -> "b"`). Dies reduziert die Bundle-Größe um bis zu 5%.
+- **Disable TypeScript Checks**: Beschleunigt Builds, indem die TypeScript-Typüberprüfung während des Kompilierungsschritts deaktiviert wird.
+
+```typescript fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  dictionary: {
+    importMode: "dynamic",
+  },
+  build: {
+    /**
+     * Minifiziert die Dictionaries, um die Bundle-Größe zu reduzieren.
+     */
+    minify: true,
+
+    /**
+     * Entfernt ungenutzte Schlüssel in Dictionaries.
+     */
+    purge: true,
+
+    /**
+     * Gibt an, ob der Build TypeScript-Typen überprüfen soll.
+     */
+    checkTypes: false,
+  },
+};
+
+export default config;
+```
+
+---
+
 ## Flexibilität: Einheitlicher Import-Modus
 
 Die boolesche Eigenschaft `live` wurde zugunsten der umfassenderen Eigenschaft `importMode` als veraltet markiert. Dies ermöglicht eine explizite Definition, wie Dictionaries geladen werden sollen: statisch, dynamisch oder via Live-Synchronisierung.
@@ -1205,6 +1358,49 @@ Markdown- und HTML-Inhalte in Svelte werden nun automatisch in HTML geparst, wen
 
 ---
 
+## Angular-Unterstützung: Vite Bundler (v8.11.0)
+
+Für Angular-Benutzer unterstützt Intlayer jetzt nativ den Vite Bundler durch ein neues benutzerdefiniertes esbuild-Plugin, was die Entwicklungs- und Build-Zeiten beschleunigt.
+
+Details zur Konfiguration finden Sie in der [Angular Environment Dokumentation](https://intlayer.org/doc/environment/angular).
+
+---
+
+## Sitemap-Generierung (v8.6.0)
+
+Intlayer generiert jetzt automatisch Sitemaps basierend auf Ihren Locales und dem Routing-Modus. Dies ist besonders nützlich für die SEO-Optimierung in Router-Architekturen wie TanStack Router:
+
+```typescript fileName="src/routes/sitemap.xml.ts"
+import { createFileRoute } from "@tanstack/react-router";
+import { generateSitemap } from "intlayer";
+
+const SITE_URL = (
+  import.meta.env.VITE_SITE_URL ?? "http://localhost:3000"
+).replace(/\/$/, "");
+
+export const Route = createFileRoute("/sitemap.xml")({
+  server: {
+    handlers: {
+      GET: async () => {
+        const sitemap = generateSitemap(
+          [
+            { path: "/", changefreq: "daily", priority: 1.0 },
+            { path: "/about", changefreq: "monthly", priority: 0.8 },
+          ],
+          { siteUrl: SITE_URL }
+        );
+
+        return new Response(sitemap, {
+          headers: { "Content-Type": "application/xml" },
+        });
+      },
+    },
+  },
+});
+```
+
+---
+
 ## Migrationshinweise von v7
 
 ### Konfigurationsänderungen