@intlayer/docs 9.0.0-canary.6 → 9.0.0-canary.8

package/docs/bn/intlayer_with_vite+vanilla.md

@@ -161,7 +161,13 @@ import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [intlayer()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 
@@ -410,12 +416,15 @@ document.querySelector<HTMLDivElement>(".edit-note")!.innerHTML =
 
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // প্রথমে রাখা উচিত
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -539,6 +548,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Babel কম্পাইলর'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 `intlayerCompiler` প্লাগিন অন্তর্ভুক্ত করতে আপনার `vite.config.ts` আপডেট করুন:
 
 ```ts fileName="vite.config.ts"
@@ -548,7 +559,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // কম্পাইলর প্লাগিন যোগ করে
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/cs/custom_domains.md

@@ -172,10 +172,16 @@ Plugin `intlayerProxy` pro Vite aplikuje stejnou logiku během vývoje:
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/cs/intlayer_with_storybook.md

@@ -152,7 +152,13 @@ const config: StorybookConfig = {
     } as const;
 
     const viteConfig = defineConfig(() => ({
-      plugins: [intlayer()],
+      plugins: [
+        intlayer({
+          proxy: {
+            ignore: (req) => req.url?.startsWith("/api"),
+          },
+        }),
+      ],
     }));
 
     return mergeConfig(baseConfig, viteConfig(env));

package/docs/cs/intlayer_with_vite+lit.md

@@ -167,7 +167,13 @@ import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [intlayer()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 
@@ -436,7 +442,7 @@ Nejprve přidejte `intlayerProxy` do své konfigurace Vite:
 
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [intlayer(), intlayerProxy()],

package/docs/cs/intlayer_with_vite+vanilla.md

@@ -167,7 +167,13 @@ import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [intlayer()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 
@@ -428,12 +434,15 @@ Nejprve přidejte `intlayerProxy` do konfigurace Vite:
 
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // mělo by být umístěno jako první
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -565,6 +574,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Babel kompilátor'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Aktualizujte svůj `vite.config.ts` a zahrňte plugin `intlayerCompiler`:
 
 ```ts fileName="vite.config.ts"
@@ -574,7 +585,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Přidá kompilátor plugin
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/de/compiler.md

@@ -81,12 +81,15 @@ Aktualisieren Sie Ihre `vite.config.ts`, um das `intlayerCompiler` Plugin einzub
 
 ```ts fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayer(),
-    intlayerCompiler(), // Fügt das Compiler-Plugin hinzu
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/de/custom_domains.md

@@ -172,10 +172,16 @@ Das `intlayerProxy` Vite-Plugin wendet die gleiche Logik während der Entwicklun
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/de/custom_url_rewrites.md

@@ -342,10 +342,16 @@ Für SolidJS, Vue und Svelte verwaltet das `intlayerProxy`-Vite-Plugin die Rewri
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/de/dynamic_dictionaries/index.md

@@ -1,13 +1,12 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
+updatedAt: 2026-06-26
 title: Dynamische Wörterbücher
-description: Übersicht über die drei dynamischen Wörterbuchfunktionen von Intlayer — Sammlungen, Varianten und dynamische Einträge — zur Erstellung flexibler, zur Laufzeit gesteuerter i18n-Inhalte.
+description: Überblick über die Funktionen für dynamische Wörterbücher von Intlayer — Sammlungen und Varianten — zum Erstellen flexibler, zur Laufzeit gesteuerter i18n-Inhalte.
 keywords:
   - Dynamische Wörterbücher
   - Sammlungen
   - Varianten
-  - Dynamische Einträge
   - Intlayer
   - Internationalisierung
 slugs:
@@ -17,38 +16,39 @@ slugs:
 history:
   - version: 9.0.0
     date: 2026-06-12
-    changes: "Veröffentlichung der dynamischen Wörterbuchfunktion"
+    changes: "Veröffentlichung der Funktion für dynamische Wörterbücher"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "Dynamische Datensätze in Varianten zusammengeführt — `variant` akzeptiert jetzt einen String oder ein Objekt"
 author: aymericzip
 ---
 
 # Dynamische Wörterbücher
 
-Intlayer unterstützt drei Mechanismen zur Darstellung von Inhalten, die über ein einzelnes statisches Wörterbuch pro Schlüssel hinausgehen. Jeder Mechanismus wird über ein **Metadatenfeld auf oberster Ebene** in der Inhaltsdatei deklariert; es ist keine Wrapper-Funktion erforderlich.
+Intlayer unterstützt zwei Mechanismen, um Inhalte auszudrücken, die über ein einzelnes statisches Wörterbuch pro Schlüssel hinausgehen. Jeder wird über ein **Metadatenfeld auf oberster Ebene** in der Inhaltsdatei deklariert; es ist keine Wrapper-Funktion nötig.
 
-| Funktion                                                                                                                     | Metadatenfeld     | Selector in `useIntlayer` |
-| ---------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------------- |
-| [Sammlungen](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/collections.md)              | `item: N`         | `{ item: N }`             |
-| [Varianten](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/variants.md)                  | `variant: "name"` | `{ variant: "name" }`     |
-| [Dynamische Einträge](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/dynamic_content.md) | `meta: { id, … }` | `{ id, … }`               |
+| Funktion                                                                                                        | Metadatenfeld                             | Selektor in `useIntlayer`                         |
+| --------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ------------------------------------------------- |
+| [Sammlungen](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/collections.md) | `item: N`                                 | `{ item: N }`                                     |
+| [Varianten](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/variants.md)     | `variant: "name"` _oder_ `variant: { … }` | `{ variant: "name" }` _oder_ `{ variant: { … } }` |
 
-Alle drei lassen sich mit dem Locale-Argument kombinieren und unterstützen selektives / Lazy Loading via `importMode`.
+Beide lassen sich mit dem locale-Argument kombinieren und unterstützen selektives / verzögertes Laden über `importMode`.
 
-<h2>Wann was zu verwenden ist</h2>
+## Wann was verwenden
 
 - **Sammlungen** — geordnete Liste von Elementen, die in separaten Dateien verwaltet werden (FAQ-Einträge, Blogbeiträge, Produkte).
-- **Varianten** — benannte Inhaltsalternativen für A/B-Tests, saisonale Banner oder Feature-Flags.
-- **Dynamische Einträge** — Inhalte, die zur Laufzeit über eine opake ID abgerufen werden (CMS-Einträge, benutzerspezifische Texte).
+- **Varianten** — benannte oder strukturierte Inhaltsalternativen:
+  - eine **String**-Variante für A/B-Tests, saisonale Banner oder Funktion-Flags;
+  - eine **Objekt**-Variante für CMS-Datensätze, benutzerspezifische Inhalte oder beliebige Inhalte, die über eine Reihe von Feldern adressiert werden (die früheren „dynamischen Datensätze").
 
-## Wann man welches verwendet
+> Frühere Versionen boten ein separates `meta`-Feld für datensatzbasierte Inhalte. Es wurde in `variant` zusammengeführt: Übergeben Sie ein **Objekt** an `variant`, anstatt `meta` zu verwenden.
 
-- **Collections** — geordnete Liste von Elementen, die in separaten Dateien verwaltet werden (FAQ-Einträge, Blogbeiträge, Produkte).
-- **Variants** — benannte Inhaltsvarianten für A/B-Tests, saisonale Banner oder Feature Flags.
-- **Dynamic records** — Inhalte, die zur Laufzeit über eine undurchsichtige ID abgerufen werden (CMS-Datensätze, benutzerspezifische Texte).
+## Selektor-Disambiguierung
 
-## Selektor-Eindeutigkeit
-
-Wenn mehrere Selektoren für ein Wörterbuch vorhanden sind, ist die Reihenfolge der Auflösung:
+Ein Schlüssel kann beide Dimensionen gleichzeitig deklarieren (z. B. eine Sammlung, deren Elemente jeweils eine Variante haben). Sie werden in dieser Reihenfolge aufgelöst:
 
 ```
-variant → meta → item
+variant → item
 ```
+
+So gibt `{ variant: "promo" }` bei einem Variant-×-Item-Schlüssel alle Promo-Elemente als Array zurück, und das Hinzufügen von `{ item: 2 }` grenzt es auf einen einzelnen Eintrag ein.

package/docs/de/dynamic_dictionaries/variants.md

@@ -1,13 +1,15 @@
 ---
 createdAt: 2026-06-12
-updatedAt: 2026-06-12
+updatedAt: 2026-06-26
 title: Varianten
-description: Verwenden Sie das Metadatenfeld variant in Inhaltsdateien von Intlayer, um benannte Inhaltsalternativen zu deklarieren (A/B-Tests, saisonale Banner, durch Feature-Flags gesteuerte Texte) und wechseln Sie zur Laufzeit ohne Codeänderungen zwischen ihnen.
+description: Verwenden Sie das variant-Metadatenfeld in Intlayer-Inhaltsdateien, um benannte oder strukturierte Inhaltsalternativen zu deklarieren — A/B-Tests, saisonale Banner, Feature-Flag-Texte, CMS-Datensätze, benutzerspezifische Inhalte — und zur Laufzeit ohne Codeänderungen zwischen ihnen zu wechseln.
 keywords:
   - Varianten
   - A/B-Tests
   - Feature-Flags
   - Dynamischer Inhalt
+  - Dynamische Datensätze
+  - CMS
   - Intlayer
   - Internationalisierung
 slugs:
@@ -18,16 +20,26 @@ history:
   - version: 9.0.0
     date: 2026-06-12
     changes: "Veröffentlichung der Varianten-Funktion"
+  - version: 9.1.0
+    date: 2026-06-26
+    changes: "`variant` akzeptiert jetzt einen String oder ein Objekt — die früheren `meta` / dynamischen Datensätze werden als Objekt-Varianten deklariert"
 author: aymericzip
 ---
 
 # Varianten
 
-Eine **Variante** (Variant) ist ein Satz von Inhaltsdateien, die denselben Wörterbuchschlüssel (`key`) teilen, aber jeweils einen anderen `variant`-Namen tragen. Intlayer liefert die entsprechende Datei basierend auf dem an `useIntlayer` übergebenen Selektor aus.
+Eine **Variante** ist eine Gruppe von Inhaltsdateien, die denselben Wörterbuch-`key` teilen, aber jeweils einen anderen `variant`-Wert tragen. Intlayer liefert die passende Datei basierend auf dem an `useIntlayer` übergebenen Selektor.
 
-## Deklarieren von Varianten
+Der `variant`-Wert kann **zwei Formen** annehmen:
 
-Jede Datei repräsentiert eine benannte Alternative. Wenn `variant` weggelassen wird (oder auf `"default"` gesetzt wird), gilt dies als Standardvariante (Fallback).
+- **Ein String** — eine einzelne benannte Alternative (A/B-Tests, saisonale Banner, Feature-Flags).
+- **Ein Objekt** — ein strukturierter Diskriminator, der über eine Reihe von Feldern adressiert wird (CMS-Datensätze, benutzerspezifische Inhalte, beliebige Inhalte mit einer opaken ID als Schlüssel). Das gesamte Objekt ist die Identität: Der Selektor muss ein **gleiches** Objekt liefern, um den Eintrag aufzulösen.
+
+> Die Objektform ersetzt das frühere `meta`-Feld. Überall, wo Sie zuvor `meta: { id, … }` geschrieben haben, schreiben Sie `variant: { id, … }` und wählen es mit `{ variant: { id, … } }` aus.
+
+## Benannte (String-)Varianten
+
+Jede Datei stellt eine benannte Alternative dar. Das Weglassen von `variant` (oder das Setzen auf `"default"`) markiert sie als Fallback.
 
 ```ts fileName="hero-banner.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
 import { t, type Dictionary } from "intlayer";
@@ -65,9 +77,9 @@ const dictionary = {
 export default dictionary;
 ```
 
-## Nutzen von Varianten
+### Benannte Varianten verwenden
 
-### Standardvariante
+#### Standardvariante
 
 <Tabs group="framework">
   <Tab label="React" value="react">
@@ -209,7 +221,7 @@ export default dictionary;
   </Tab>
 </Tabs>
 
-### Benannte Variante
+#### Benannte Variante
 
 ```tsx
 const { headline, cta } = useIntlayer("hero-banner", {
@@ -217,18 +229,264 @@ const { headline, cta } = useIntlayer("hero-banner", {
 });
 ```
 
-### Benannte Variante mit explizitem Locale
+#### Benannte Variante mit explizitem Locale
 
 ```tsx
 const content = useIntlayer("hero-banner", {
   variant: "black_friday",
-  locale: "de",
+  locale: "fr",
 });
 ```
 
+## Objekt-Varianten (strukturiert)
+
+Eine Objekt-Variante adressiert Inhalte über eine beliebige Menge von Schlüssel-Wert-Paaren, die im `variant`-Feld deklariert sind — wodurch sich CMS-Datensätze, benutzerspezifische Inhalte oder beliebige Inhalte mit einer opaken ID als Schlüssel modellieren lassen. Das **gesamte Objekt** ist die Identität: Der Selektor muss ein gleiches Objekt liefern, damit der Eintrag aufgelöst wird.
+
+```ts fileName="product.abc.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { t, type Dictionary } from "intlayer";
+
+const dictionary = {
+  key: "product",
+  variant: { id: "prod_abc", userId: "user_123" },
+  content: {
+    name: t({ en: "Widget Pro", fr: "Widget Pro" }),
+    description: t({ en: "The best widget.", fr: "Le meilleur widget." }),
+  },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+```ts fileName="product.abcd.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { t, type Dictionary } from "intlayer";
+
+const dictionary = {
+  key: "product",
+  variant: { id: "prod_abcd", userId: "user_123" },
+  content: {
+    name: t({ en: "Widget Lite", fr: "Widget Lite" }),
+    description: t({ en: "A lighter option.", fr: "Une option plus légère." }),
+  },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+### Objekt-Varianten verwenden
+
+Übergeben Sie das passende Objekt an `variant`. Jedes im Wörterbuch deklarierte Feld muss angegeben und gleich sein; andernfalls ist das Ergebnis `null`. Die Reihenfolge der Felder spielt keine Rolle.
+
+<Tabs group="framework">
+  <Tab label="React" value="react">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "react-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Next.js" value="nextjs">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "next-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Vue" value="vue">
+    ```vue fileName="Product.vue" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script setup>
+    import { useIntlayer } from "vue-intlayer";
+
+    const props = defineProps({
+      productId: String,
+      userId: String,
+    });
+
+    const content = useIntlayer("product", {
+      variant: { id: props.productId, userId: props.userId },
+    });
+    </script>
+
+    <template>
+      <p v-if="content">{{ content.description }}</p>
+    </template>
+    ```
+
+  </Tab>
+  <Tab label="Svelte" value="svelte">
+    ```svelte fileName="Product.svelte" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    <script lang="ts">
+    import { useIntlayer } from "svelte-intlayer";
+
+    export let productId: string;
+    export let userId: string;
+
+    const content = useIntlayer("product", {
+      variant: { id: productId, userId },
+    });
+    </script>
+
+    {#if $content}
+      <p>{$content.description}</p>
+    {/if}
+    ```
+
+  </Tab>
+  <Tab label="Preact" value="preact">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "preact-intlayer";
+
+    export const Product = ({
+      productId,
+      userId,
+    }: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: productId, userId },
+      });
+
+      if (!content) return null;
+
+      return <p>{content.description}</p>;
+    };
+    ```
+
+  </Tab>
+  <Tab label="Solid" value="solid">
+    ```tsx fileName="Product.tsx" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { useIntlayer } from "solid-intlayer";
+
+    export const Product = (props: {
+      productId: string;
+      userId: string;
+    }) => {
+      const content = useIntlayer("product", {
+        variant: { id: props.productId, userId: props.userId },
+      });
+
+      return (
+        <>
+          {content() && <p>{content().description}</p>}
+        </>
+      );
+    };
+    ```
+
+  </Tab>
+  <Tab label="Angular" value="angular">
+    ```typescript fileName="product.component.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+    import { Component, Input, OnInit } from "@angular/core";
+    import { useIntlayer } from "angular-intlayer";
+
+    @Component({
+      selector: "app-product",
+      template: `
+        @if (content()) {
+          <p>{{ content().description }}</p>
+        }
+      `,
+    })
+    export class ProductComponent implements OnInit {
+      @Input() productId!: string;
+      @Input() userId!: string;
+
+      content: any;
+
+      ngOnInit() {
+        this.content = useIntlayer("product", {
+          variant: { id: this.productId, userId: this.userId },
+        });
+      }
+    }
+    ```
+
+  </Tab>
+  <Tab label="Vanilla JS" value="vanilla">
+    ```javascript fileName="product.js"
+    import { useIntlayer } from "vanilla-intlayer";
+
+    const content = useIntlayer("product", {
+      variant: { id: "prod_abcd", userId: "user_123" },
+    });
+
+    if (content) {
+      document.body.innerHTML = `<p>${content.description}</p>`;
+    }
+    ```
+
+  </Tab>
+</Tabs>
+
+#### Mit explizitem Locale
+
+```tsx
+const content = useIntlayer("product", {
+  variant: { id: "prod_abc", userId: "user_123" },
+  locale: "fr",
+});
+```
+
+#### Fehlendes Feld — keine Übereinstimmung
+
+```ts
+// Gibt null zurück: `userId` fehlt, daher passt das Objekt nicht zur deklarierten Variante
+const content = useIntlayer("product", { variant: { id: "prod_abc" } });
+```
+
+## Lademodus
+
+Objekt-Varianten werden oft verzögert geladen. Setzen Sie `importMode` im Wörterbuch, um dies zu steuern:
+
+```ts contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+const dictionary = {
+  key: "product",
+  importMode: "fetch", // or "dynamic"
+  variant: { id: "prod_abc", userId: "user_123" },
+  content: { … },
+} satisfies Dictionary;
+
+export default dictionary;
+```
+
+Siehe [Bundle-Optimierung](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/bundle_optimization.md) für Details zu den Modi `static`, `dynamic` und `fetch`.
+
 ## Typische Anwendungsfälle
 
-- A/B-Kopiertests, die durch einen Experiment-Schlüssel gesteuert werden
-- Saisonale oder Werbe-Banner
-- Über Feature-Flags gesteuerte Nachrichten
-- Lokalspezifische Marketingkampagnen
+- A/B-Texttests, gesteuert durch einen Experiment-Schlüssel
+- Saisonale oder Werbebanner
+- Feature-Flag-gesteuerte Nachrichten
+- Locale-spezifische Marketingkampagnen
+- Produktspezifische Marketingtexte, die in einem CMS verwaltet werden
+- Benutzer- oder kontospezifische Inhalte
+- Beliebige Inhalte, die durch eine opake Laufzeit-ID adressiert werden

package/docs/de/intlayer_with_analog.md

@@ -207,7 +207,11 @@ import analog from "@analogjs/platform";
 export default defineConfig(() => ({
   plugins: [
     analog(),
-    intlayer(), // Fügen Sie das Intlayer-Plugin hinzu
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 }));
 ```

package/docs/de/intlayer_with_astro.md

@@ -517,6 +517,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Babel-Compiler'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Aktualisieren Sie Ihre `vite.config.ts`, um das `intlayerCompiler`-Plugin aufzunehmen:
 
 ```ts fileName="vite.config.ts"
@@ -526,7 +528,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Fügt das Compiler-Plugin hinzu
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```