@intlayer/docs 9.4.0-canary.0 → 9.4.1

package/docs/de/packages/intlayer/getDictionary.md

@@ -0,0 +1,155 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getDictionary Function Documentation | intlayer
+description: Erfahren Sie, wie Sie die getDictionary-Funktion für das intlayer-Paket verwenden
+keywords:
+  - getDictionary
+  - dictionary
+  - interpreter
+  - content
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getDictionary
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Dokumentation: `getDictionary`-Funktion in `intlayer`
+
+## Beschreibung
+
+Die Funktion `getDictionary` interpretiert ein Dictionary-**Objekt, das Sie selbst übergeben**, und gibt seinen aufgelösten Inhalt für ein bestimmtes Locale zurück. Sie durchläuft den Inhalt in einem einzigen Durchgang und wendet bei Bedarf jedes Interpreter-Plugin an, wobei `t()`-Übersetzungen, Enumerationen, Bedingungen, Einfügungen, Verschachtelung, Markdown, HTML und Datei-Knoten aufgelöst werden.
+
+Im Gegensatz zu [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayer.md), das ein Dictionary anhand eines Schlüssels in der generierten Registry nachschlägt, nimmt `getDictionary` das Dictionary selbst entgegen. Dies macht es zum richtigen Werkzeug für Inhalte, die zur Laufzeit erstellt, von einer API oder einem CMS abgerufen oder inline in einem Test deklariert werden.
+
+**Hauptfunktionen:**
+
+- Funktioniert mit jedem Objekt, das der Dictionary-Struktur folgt (`{ key, content }`)
+- Akzeptiert auch eine qualifizierte Dictionary-Gruppe (Collections, Varianten) zusammen mit einem Selector
+- Vollständig typisiert: Das zurückgegebene Objekt spiegelt den `content` wider, den Sie übergeben haben
+- Akzeptiert benutzerdefinierte Interpreter-Plugins
+
+---
+
+## Funktionssignatur
+
+```typescript
+getDictionary(
+  dictionary: Dictionary | QualifiedDictionaryGroup, // Erforderlich
+  localeOrSelector?: LocalesValues | DictionarySelector, // Optional
+  plugins?: Plugins[]                                // Optional
+): DeepTransformContent<...>
+```
+
+---
+
+## Parameter
+
+- `dictionary: Dictionary | QualifiedDictionaryGroup`
+  - **Beschreibung**: Das zu interpretierende Wörterbuch (oder die qualifizierte Wörterbuchgruppe).
+  - **Typ**: `Dictionary | QualifiedDictionaryGroup`
+  - **Erforderlich**: Ja
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Beschreibung**: Das Locale zur Interpretation des Inhalts oder ein Selector-Objekt (`{ item }`, `{ variant }`, optional mit `locale`). Siehe [dynamische Wörterbücher](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/index.md).
+  - **Typ**: `LocalesValues | DictionarySelector`
+  - **Erforderlich**: Nein (Optional) — wird standardmäßig auf das konfigurierte `defaultLocale` gesetzt.
+
+- `plugins: Plugins[]`
+  - **Beschreibung**: Ein Array von Node-Transformern, die definieren, wie erkannte Knoten interpretiert werden. Wenn weggelassen, wird der Standard-Satz von Interpreter-Plugins verwendet.
+  - **Typ**: `Plugins[]`
+  - **Erforderlich**: Nein (Optional)
+
+### Rückgabewerte
+
+- **Typ**: Der interpretierte Inhalt des Wörterbuchs.
+- **Beschreibung**: Der `content`, den Sie übergeben haben, mit jedem aufgelösten Intlayer-Knoten für das angeforderte Gebietsschema. Für eine Sammlungsgruppe ohne einen `item`-Selector wird ein geordnetes Array interpretierter Einträge zurückgegeben; `null` wird zurückgegeben, wenn der Selector nichts anvisiert.
+
+---
+
+## Beispielverwendung
+
+### Grundlegende Verwendung
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getDictionary, t } from "intlayer";
+
+const content = getDictionary(
+  {
+    key: "my_key",
+    content: {
+      greeting: t({
+        de: "Hallo",
+        en: "Hello",
+        fr: "Bonjour",
+      }),
+    },
+  },
+  "de"
+);
+
+console.log(content.greeting); // "Hallo"
+```
+
+### Interpretation von zur Laufzeit abgerufenem Inhalt
+
+```typescript
+import { getDictionary, type Dictionary } from "intlayer";
+
+const remoteDictionary: Dictionary = await fetch("/api/cms/banner").then(
+  (res) => res.json()
+);
+
+const banner = getDictionary(remoteDictionary, "fr");
+```
+
+### Mit einem Selector
+
+```typescript
+import { getDictionary } from "intlayer";
+
+// Eine qualifizierte Wörterbuchgruppe wird in einen einzelnen Eintrag aufgelöst…
+const secondItem = getDictionary(blogPostGroup, { item: 2, locale: "fr" });
+
+// …oder in ein geordnetes Array, wenn kein `item` angegeben wird
+const allItems = getDictionary(blogPostGroup, { locale: "fr" });
+```
+
+---
+
+## Verwandte Funktionen
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayer.md): Gleiche Interpretation, aber das Dictionary wird nach Schlüssel in der generierten Registry gesucht.
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getDictionaryAsync.md): Gegenstück für Pro-Locale-Loader-Maps.
+- [`useDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/react-intlayer/useDictionary.md): Das React Hook-Äquivalent, das das Locale vom Provider ausliest.
+
+---
+
+## TypeScript
+
+```typescript
+function getDictionary<
+  const T extends Dictionary | QualifiedDictionaryGroup,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  dictionary: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): DeepTransformContent<
+  ResolveQualifiedDictionaryContent<T, A>,
+  IInterpreterPluginState,
+  ExtractSelectorLocale<A>
+>;
+```

package/docs/de/packages/intlayer/getDictionaryAsync.md

@@ -0,0 +1,166 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getDictionaryAsync Function Documentation | intlayer
+description: Erfahren Sie, wie Sie die getDictionaryAsync-Funktion für das intlayer-Paket verwenden
+keywords:
+  - getDictionaryAsync
+  - dictionary
+  - dynamic dictionaries
+  - loader map
+  - bundle optimization
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getDictionaryAsync
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Dokumentation: `getDictionaryAsync` Funktion in `intlayer`
+
+## Beschreibung
+
+Die `getDictionaryAsync` Funktion lädt einen **einzelnen Locale-Chunk** eines Wörterbuchs und gibt seinen interpretierten Inhalt zurück.
+
+Sie ist das Gegenstück von [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getDictionary.md) für die pro-Locale Loader Maps, die in `.intlayer/dynamic_dictionaries/` emittiert werden: Anstatt ein Wörterbuch zu erhalten, das jede Locale enthält, erhält sie die Loader Map und wartet nur auf den Chunk, den die angeforderte Locale benötigt.
+
+> Im Anwendungscode rufen Sie normalerweise [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayerAsync.md) auf, nicht diese Funktion. Die [Build Plugins](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/bundle_optimization.md) schreiben jeden `getIntlayerAsync('key', locale)` Aufruf in einen `getDictionaryAsync(loaderMap, 'key', locale)` Aufruf um. `getDictionaryAsync` wird für benutzerdefinierte Loader und für Tools exportiert, die ihre eigenen Loader Maps erstellen.
+
+**Hauptmerkmale:**
+
+- Lädt nur den Locale-Chunk, der angefordert wird
+- Unterstützt einfache (`locale → loader`) und qualifizierte (`locale → qualifierId → loader`) Loader Maps
+- Dedupliziert gleichzeitige Ladevorgänge des gleichen Chunks und cacht den aufgelösten Inhalt
+- Fehlgeschlagene Ladevorgänge werden aus dem Cache entfernt, sodass ein späterer Aufruf den Chunk erneut versucht
+
+---
+
+## Funktionssignatur
+
+```typescript
+getDictionaryAsync(
+  dictionaryLoaders: PlainDynamicLoaderMap | QualifiedDynamicLoaderMap, // Erforderlich
+  key: string,                                           // Erforderlich
+  localeOrSelector?: LocalesValues | DictionarySelector, // Optional
+  plugins?: Plugins[]                                    // Optional
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## Parameter
+
+- `dictionaryLoaders: PlainDynamicLoaderMap | QualifiedDynamicLoaderMap`
+  - **Beschreibung**: Die Loader-Map pro Locale. Plain Maps verknüpfen ein Locale mit einem Loader; qualified Maps (verwendet für Collections und Varianten) verknüpfen ein Locale mit einer Qualifier-ID und dann mit einem Loader. Bei einer qualified Map werden nur die Chunk(s) geladen, auf die der Selector abzielt.
+  - **Typ**: `PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap`
+  - **Erforderlich**: Ja
+
+- `key: string`
+  - **Beschreibung**: Der Dictionary-Key, wird zur Namespacing des Chunk-Cache verwendet.
+  - **Typ**: `string`
+  - **Erforderlich**: Ja
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Beschreibung**: Das Locale zur Interpretation des Inhalts oder ein Selector-Objekt (`{ item }`, `{ variant }`, optional mit `locale`). Siehe [dynamische Dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/index.md).
+  - **Typ**: `LocalesValues | DictionarySelector`
+  - **Erforderlich**: Nein (Optional) — standardmäßig das konfigurierte `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Beschreibung**: Node-Transformer. Standardmäßig das Base-Interpreter-Set.
+  - **Typ**: `Plugins[]`
+  - **Erforderlich**: Nein (Optional)
+
+### Returns
+
+- **Type**: `Promise<Content>` — a promise resolving to the interpreted content of the loaded chunk.
+- **Description**: Resolves to `null` when the map emits no chunk for the requested locale nor for any of its fallbacks, mirroring how a missing qualified coordinate resolves.
+
+---
+
+## Beispielverwendung
+
+### Mit einer generierten Loader-Map
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getDictionaryAsync } from "intlayer";
+import appLoaderMap from "../.intlayer/dynamic_dictionaries/app";
+
+const { title } = await getDictionaryAsync(appLoaderMap, "app", "fr");
+```
+
+### Mit einer benutzerdefinierten Loader-Map
+
+```typescript
+import { getDictionaryAsync } from "intlayer";
+
+const loaderMap = {
+  en: () => import("./banner.en.json").then((mod) => mod.default),
+  fr: () => import("./banner.fr.json").then((mod) => mod.default),
+};
+
+const banner = await getDictionaryAsync(loaderMap, "banner", "fr");
+```
+
+### Mit einem Selector auf einer qualified map
+
+```typescript
+import { getDictionaryAsync } from "intlayer";
+
+const promoBanner = await getDictionaryAsync(bannerLoaderMap, "banner", {
+  variant: "black-friday",
+  locale: "fr",
+});
+```
+
+---
+
+## Verhaltenshinweise
+
+### Caching und Deduplication
+
+Der Cache speichert das **Promise** jedes `key + locale + selector` Triplets, sodass gleichzeitige Aufrufe für denselben Chunk auf einen einzelnen Load warten. Ein abgelehnter Load wird aus dem Cache entfernt, sodass ein fehlgeschlagener Chunk beim nächsten Aufruf erneut versucht wird, anstatt denselben Fehler immer wieder zu wiederholen.
+
+### Locale-Fallback
+
+Eine einfache Loader-Map wird entlang der gleichen Fallback-Kette wie im synchronen Modus durchlaufen: zuerst das angeforderte Locale, dann seine Fallbacks, dann `null`, wenn keiner einen Chunk ausgegeben hat.
+
+---
+
+## Verwandte Funktionen
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayerAsync.md): Die Funktion, die Anwendungen aufrufen; Build-Plugins schreiben sie in `getDictionaryAsync` um.
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getDictionary.md): Synchrones Pendant, das ein vollständiges Dictionary nimmt.
+- [Dynamische Dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/index.md): Collections und Varianten sowie die Loader-Maps, die sie generieren.
+
+---
+
+## TypeScript
+
+```typescript
+function getDictionaryAsync<
+  const T extends Dictionary,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  dictionaryLoaders: PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap,
+  key: string,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): Promise<
+  DeepTransformContent<
+    T["content"],
+    IInterpreterPluginState,
+    ExtractSelectorLocale<A>
+  >
+>;
+```

package/docs/de/packages/intlayer/getEnumeration.md

@@ -31,6 +31,8 @@ author: aymericzip
 
 Die Funktion `getEnumeration` ruft Inhalte ab, die einer bestimmten Menge entsprechen, basierend auf vordefinierten Bedingungen in einem Enumerationsobjekt. Die Bedingungen sind als Schlüssel definiert, und ihre Priorität wird durch ihre Reihenfolge im Objekt bestimmt.
 
+Weitere Informationen zur Deklaration von Enumerationen finden Sie in der [Enumeration-Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/enumeration.md).
+
 ## Parameter
 
 - `enumerationContent: QuantityContent<Content>`

package/docs/de/packages/intlayer/getIntlayer.md

@@ -0,0 +1,197 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getIntlayer Function Documentation | intlayer
+description: Siehe, wie du die getIntlayer-Funktion für das intlayer-Paket verwendest
+keywords:
+  - getIntlayer
+  - dictionary
+  - content
+  - selector
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Dokumentation: `getIntlayer` Funktion in `intlayer`
+
+## Beschreibung
+
+Die Funktion `getIntlayer` wählt ein Wörterbuch nach seinem Schlüssel aus und gibt seinen Inhalt interpretiert für ein bestimmtes Gebietsschema zurück. Sie ist das Framework-agnostische Äquivalent des Hooks `useIntlayer`: derselbe Inhalt, dieselben Selektoren, aber überall dort einsetzbar, wo ein React Context nicht verfügbar ist — Node-Skripte, Server-Funktionen, Route Loader, Metadata-Builder, Express/Fastify-Handler, Tests.
+
+Sie liest die von Intlayer in `.intlayer/` generierten Wörterbücher, sodass das Argument `key` typisiert und automatisch aus deinen eigenen Content-Deklarationen vervollständigt wird, und das zurückgegebene Objekt ist vollständig typisiert bis auf jedes Blatt.
+
+**Hauptfunktionen:**
+
+- Typisierte Wörterbuch-Schlüssel und typisierter zurückgegebener Inhalt
+- Interpretiert jeden Content-Knoten (`t()`, `enu()`, `cond()`, `insert()`, `nest()`, `md()`, `html()`, `file()`, `gender()`)
+- Akzeptiert ein Gebietsschema oder ein Selector-Objekt (Collections, Varianten)
+- Ergebnisse werden pro `key + locale + selector` im Speicher gespeichert
+- Fällt in der Entwicklung auf einen sicheren Proxy zurück, wenn ein Wörterbuch fehlt, anstatt zu crashen
+
+---
+
+## Funktionssignatur
+
+```typescript
+getIntlayer(
+  key: DictionaryKeys,                        // Erforderlich
+  localeOrSelector?: LocalesValues | DictionarySelector, // Optional
+  plugins?: Plugins[]                         // Optional
+): DeepTransformContent<...>
+```
+
+---
+
+## Parameter
+
+- `key: DictionaryKeys`
+  - **Description**: Der Schlüssel des zu lesenden Wörterbuchs, wie in deinen Content-Dateien deklariert.
+  - **Type**: `DictionaryKeys` — eine Vereinigung aller deklarierten Wörterbuchschlüssel.
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: Das Locale zur Interpretation des Inhalts oder ein Selector-Objekt für [dynamische Wörterbücher](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/index.md).
+    - `'fr'` — ein Locale
+    - `{ item: 2 }` — ein [collection](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/collections.md) Element (omit `item` um alle Elemente als Array zu erhalten)
+    - `{ variant: 'black-friday' }` — eine benannte [variant](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/variants.md) (omit für die `default`)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — eine strukturierte Variante
+    - Jeder Selector kann ein Locale enthalten: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Custom Node Transformer, die die Basis-Interpreter-Plugins ersetzen. Nur für fortgeschrittene Verwendung; omit it to keep the default behaviour.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Rückgabewert
+
+- **Type**: Der interpretierte Inhalt des Wörterbuchs, typisiert aus Ihrer Deklaration.
+- **Description**: Ein einfaches Objekt, das das `content`-Feld Ihres Wörterbuchs widerspiegelt, wobei jeder Intlayer-Knoten auf seinen Endwert für das angeforderte Locale aufgelöst wurde.
+
+---
+
+## Beispielverwendung
+
+### Grundlegende Verwendung
+
+```typescript fileName="src/app.content.ts" codeFormat="typescript"
+import { t, type Dictionary } from "intlayer";
+
+const appContent = {
+  key: "app",
+  content: {
+    title: t({
+      de: "Hallo",
+      en: "Hello",
+      fr: "Bonjour",
+    }),
+  },
+} satisfies Dictionary;
+
+export default appContent;
+```
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app", "de"); // "Hallo"
+```
+
+### Ohne Locale
+
+Das Weglassen der Locale interpretiert den Inhalt mit dem `defaultLocale`, der in Ihrer [Konfiguration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md) deklariert ist.
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app"); // Interpretiert mit der Standard-Locale
+```
+
+### Inside a server handler
+
+```typescript fileName="src/routes/greeting.ts" codeFormat="typescript"
+import { getIntlayer, getLocale } from "intlayer";
+
+export const greetingHandler = async (request: Request) => {
+  const locale = await getLocale({
+    getHeader: (name) => request.headers.get(name) ?? undefined,
+  });
+
+  const { title } = getIntlayer("app", locale);
+
+  return Response.json({ title });
+};
+```
+
+### Mit einem Selector (Collections und Varianten)
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+// Ein einzelnes Collection-Element
+const secondPost = getIntlayer("blog-post", { item: 2, locale: "fr" });
+
+// Alle Elemente der Collection als sortiertes Array
+const allPosts = getIntlayer("blog-post", { locale: "fr" });
+
+// Eine benannte Variante
+const banner = getIntlayer("banner", { variant: "black-friday", locale: "fr" });
+```
+
+---
+
+## Verhaltenshinweise
+
+### Caching
+
+Ergebnisse werden in einem Cache auf Modulebene zwischengespeichert, dessen Schlüssel `key + locale + selector` ist. Das wiederholte Aufrufen von `getIntlayer("app", "fr")` interpretiert das Dictionary einmal und gibt danach immer dasselbe Objekt zurück.
+
+### Fehlende Wörterbücher
+
+Beim Anfordern eines Schlüssels, der kein generiertes Wörterbuch hat, protokolliert die Entwicklung eine Warnung einmal und gibt einen sicheren Fallback-Proxy zurück: Das Lesen von `content.title` ergibt die Zeichenkette `"app.title"` anstatt einen Fehler auszulösen. Dies hält eine Seite nutzbar, während die fehlende Deklaration behoben wird. Führen Sie den Intlayer-Build (oder den Dev-Server) aus, damit das Wörterbuch generiert wird.
+
+### Bundle-Größe
+
+`getIntlayer` liest das zusammengeführte Wörterbuch, das **jedes** Locale enthält. In Client-Bundles schreiben die [Build-Plugins](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/bundle_optimization.md) den Aufruf um, sodass nur der erforderliche Inhalt ausgeliefert wird. Wenn Sie Inhalte außerhalb des Rendering lesen (Metadaten, Loaders, Server-Funktionen) und ein einzelnes Locale bei Bedarf laden möchten, verwenden Sie stattdessen [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayerAsync.md).
+
+---
+
+## Verwandte Funktionen
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayerAsync.md): Asynchrones Äquivalent, das einen einzelnen Locale-Chunk lädt.
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getDictionary.md): Interpretiert ein Wörterbuch-Objekt, das Sie selbst übergeben, anstatt eines, das nach Schlüssel nachgeschlagen wird.
+- [`useIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/react-intlayer/useIntlayer.md): Das React-Hook-Äquivalent, das das Locale vom Provider liest.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayer<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): DeepTransformContent<
+  DictionaryRegistryResult<T, A>,
+  IInterpreterPluginState,
+  ExtractSelectorLocale<A>
+>;
+```

package/docs/de/packages/intlayer/getIntlayerAsync.md

@@ -0,0 +1,141 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getIntlayerAsync Function Documentation | intlayer
+description: See how to use the getIntlayerAsync function for intlayer package
+keywords:
+  - getIntlayerAsync
+  - dictionary
+  - dynamic import
+  - metadata
+  - bundle optimization
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayerAsync
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Dokumentation: `getIntlayerAsync` Funktion in `intlayer`
+
+## Beschreibung
+
+Die Funktion `getIntlayerAsync` wählt ein Dictionary nach seinem Schlüssel aus und löst seinen Inhalt für ein bestimmtes Locale auf, **wobei nur dieses Locale geladen wird**.
+
+Es ist das asynchrone Gegenstück zu [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayer.md), gedacht für Stellen, an denen ein Dictionary außerhalb des Rendering gelesen wird — Route `head` / Metadata Builder, Loader, Server Functions.
+
+Während `getIntlayer` das zusammengeführte Dictionary mit jedem Locale einzieht, schreiben die [Build Plugins](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/bundle_optimization.md) (`@intlayer/babel`, `@intlayer/swc`) diesen Aufruf in `getDictionaryAsync(loaderMap, key, locale)` um und verweisen auf die Locale-spezifischen Chunks in `.intlayer/dynamic_dictionaries/`. Das Bundle enthält daher nur noch das tatsächlich angeforderte Locale.
+
+Ohne diese Plugins — ein nicht optimierter Build — wird der Aufruf stattdessen durch die synchrone Dictionary Registry aufgelöst: derselbe Inhalt, aber ohne die Locale-spezifische Aufteilung.
+
+**Wichtigste Funktionen:**
+
+- Gleiche typisierte Schlüssel, Selektoren und zurückgegebener Inhalt wie `getIntlayer`
+- Lädt in optimierten Builds nur den angeforderten Locale-Chunk
+- Gleichzeitige Aufrufe für denselben Chunk teilen sich einen einzelnen Load
+- Sicher zu verwenden in `async` Metadata Buildern, Loadern und Server Functions
+
+---
+
+## Funktionssignatur
+
+```typescript
+getIntlayerAsync(
+  key: DictionaryKeys,                        // Erforderlich
+  localeOrSelector?: LocalesValues | DictionarySelector, // Optional
+  plugins?: Plugins[]                         // Optional
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## Parameter
+
+- `key: DictionaryKeys`
+  - **Beschreibung**: Der Schlüssel des zu lesenden Wörterbuchs, wie in deinen Content-Dateien deklariert.
+  - **Typ**: `DictionaryKeys` — eine Union aller deklarierten Wörterbuchschlüssel.
+  - **Erforderlich**: Ja
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Beschreibung**: Die Locale zur Interpretation des Inhalts oder ein Selector-Objekt für [dynamische Wörterbücher](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/index.md).
+    - `'fr'` — eine Locale
+    - `{ item: 2 }` — ein [collection](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/collections.md)-Element (omit `item` um jedes Element als Array zu erhalten)
+    - `{ variant: 'black-friday' }` — eine benannte [variant](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/variants.md) (omit für die `default`)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — eine strukturierte Variante
+    - Jeder Selector kann eine Locale tragen: `{ item: 2, locale: 'fr' }`
+  - **Typ**: `LocalesValues | DictionarySelector`
+  - **Erforderlich**: Nein (Optional) — standardmäßig auf die konfigurierte `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Beschreibung**: Benutzerdefinierte Node-Transformer, die die Standard-Interpreter-Plugins ersetzen. Nur für fortgeschrittene Verwendung.
+  - **Typ**: `Plugins[]`
+  - **Erforderlich**: Nein (Optional)
+
+### Rückgabewert
+
+- **Type**: `Promise<Content>` — ein Promise, das sich zum interpretierten Inhalt des Wörterbuchs auflöst, typisiert aus Ihrer Deklaration.
+
+---
+
+## Beispielverwendung
+
+### Grundlegende Verwendung
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayerAsync } from "intlayer";
+
+const { title } = await getIntlayerAsync("app", "fr"); // "Bonjour"
+```
+
+---
+
+## `getIntlayer` vs `getIntlayerAsync`
+
+|                    | [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayer.md) | `getIntlayerAsync`                                          |
+| ------------------ | --------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
+| Returns            | Der Inhalt                                                                                                      | Ein Promise des Inhalts                                     |
+| Dictionary loaded  | Das zusammengeführte Wörterbuch (alle Locales)                                                                  | Das Chunk der angeforderten Locale nur                      |
+| Best suited for    | Rendering, synchrone Code-Pfade                                                                                 | Metadaten, Loader, Server-Funktionen                        |
+| Requires a plugin? | Nein                                                                                                            | Nein — die Per-Locale-Aufteilung benötigt die Build-Plugins |
+
+Beide akzeptieren die gleichen Argumente und geben den gleichen Inhalt zurück: Der Wechsel von einem zum anderen ändert nur **wann** und **wie viel** geladen wird.
+
+---
+
+## Verwandte Funktionen
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayer.md): Synchrones Äquivalent, das das zusammengeführte Dictionary liest.
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getDictionaryAsync.md): Die Low-Level-Funktion, die die Build-Plugins in diesen Aufruf umschreiben.
+- [`getLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getLocale.md): Erkennt das Locale einer eingehenden Anfrage.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayerAsync<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): Promise<
+  DeepTransformContent<
+    DictionaryRegistryResult<T, A>,
+    IInterpreterPluginState,
+    ExtractSelectorLocale<A>
+  >
+>;
+```