@intlayer/docs 9.3.3 → 9.4.0

package/docs/de/packages/elysia-intlayer/exports.md

@@ -0,0 +1,136 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: elysia-intlayer Paketdokumentation
+description: Elysia-Plugin für Intlayer, das Übersetzungsfunktionen und Locale-Erkennung bereitstellt.
+keywords:
+  - elysia-intlayer
+  - elysia
+  - plugin
+  - Internationalisierung
+  - i18n
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - exports
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Vereinheitlichte Dokumentation für alle Exporte"
+author: aymericzip
+---
+
+# elysia-intlayer Paket
+
+Das `elysia-intlayer`-Paket stellt ein Plugin für Elysia-Anwendungen bereit, um Internationalisierung zu unterstützen. Es erkennt die Locale des Benutzers und injiziert ein `intlayer`-Objekt in den Route-Kontext.
+
+## Installation
+
+```bash packageManager="npm"
+npm install intlayer elysia-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add intlayer elysia-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add intlayer elysia-intlayer
+```
+
+```bash packageManager="bun"
+bun add intlayer elysia-intlayer
+```
+
+> `elysia` ist eine Peer-Dependency (`>=1.0.0`). Elysia zielt auf die **Bun**-Runtime ab.
+
+## Exporte
+
+### Plugin
+
+Import:
+
+```ts
+import { intlayer } from "elysia-intlayer";
+```
+
+| Funktion   | Beschreibung                                                                                                                                                                                                                                                                                                                                 | Zugehörige Dokumentation                                                                                       |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `intlayer` | Elysia-Plugin, das Intlayer in Ihre Elysia-Anwendung integriert. Übernimmt die Locale-Erkennung aus dem Storage (Cookies, Header) und anschließend aus `Accept-Language`, injiziert ein `intlayer`-Objekt mit `locale`, `t`, `getIntlayer` und `getDictionary` in den Route-Kontext und richtet den `AsyncLocalStorage`-Request-Kontext ein. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/elysia-intlayer/intlayer.md) |
+
+### Funktionen
+
+Import:
+
+```ts
+import { t, getIntlayer, getDictionary } from "elysia-intlayer";
+```
+
+| Funktion        | Beschreibung                                                                                                                                                                                                                                                                                        | Zugehörige Dokumentation                                                                               |
+| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Globale Übersetzungsfunktion, die den Inhalt für die aktuelle Locale in Elysia abruft. Verwendet `AsyncLocalStorage`, um auf den vom `intlayer`-Plugin eingerichteten Request-Kontext zuzugreifen, und greift außerhalb davon auf die Standard-Locale zurück. Auch über `intlayer.t` erreichbar.    | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/translation.md) |
+| `getIntlayer`   | Ruft ein Wörterbuch anhand seines Schlüssels aus der generierten Deklaration ab und gibt dessen Inhalt für die aktuelle Locale zurück. Optimierte Variante von `getDictionary`. Verwendet `AsyncLocalStorage`, um auf den Request-Kontext zuzugreifen. Auch über `intlayer.getIntlayer` erreichbar. | -                                                                                                      |
+| `getDictionary` | Verarbeitet Wörterbuchobjekte und gibt den Inhalt für die aktuelle Locale zurück. Verarbeitet `t()`-Übersetzungen, Enumerationen, Markdown, HTML usw. Verwendet `AsyncLocalStorage`, um auf den Request-Kontext zuzugreifen. Auch über `intlayer.getDictionary` erreichbar.                         | -                                                                                                      |
+
+### Typen
+
+Import:
+
+```ts
+import type { IntlayerContext, TranslateFunction } from "elysia-intlayer";
+```
+
+| Typ                 | Beschreibung                                                                                                                                                                 |
+| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `IntlayerContext`   | Form des `intlayer`-Objekts, das in jeden Route-Kontext injiziert wird: `locale`, `locale_storage`, `locale_detected`, `defaultLocale`, `t`, `getIntlayer`, `getDictionary`. |
+| `TranslateFunction` | Signatur der Übersetzungsfunktion, die eine Locale-Map in den Inhalt der aktuellen Request-Locale übersetzt.                                                                 |
+
+## Verwendung
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { getDictionary, getIntlayer, intlayer, t } from "elysia-intlayer";
+import dictionaryExample from "./index.content";
+
+const app = new Elysia()
+  // Laden Sie das Internationalisierungs-Plugin
+  .use(intlayer())
+  // Locale und Helper aus dem Route-Context lesen
+  .get("/", ({ intlayer }) => ({
+    locale: intlayer!.locale,
+    greeting: intlayer!.t({
+      de: "Hallo",
+      en: "Hello",
+      fr: "Bonjour",
+      es: "Hola",
+    }),
+    content: intlayer!.getIntlayer("index").exampleOfContent,
+  }))
+  // Oder die Standalone-Helper verwenden, die an die aktuelle Anfrage gebunden sind
+  .get("/t_example", () =>
+    t({
+      de: "Beispiel für zurückgegebene Inhalte auf Deutsch",
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      es: "Ejemplo de contenido devuelto en español",
+    })
+  )
+  .get("/getIntlayer_example", () => getIntlayer("index").exampleOfContent)
+  .get(
+    "/getDictionary_example",
+    () => getDictionary(dictionaryExample).exampleOfContent
+  )
+  .listen(3000);
+
+console.log(
+  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
+);
+```
+
+> Das Plugin registriert seinen Context über ein **globales** `derive`, das Elysia als `Partial<{ intlayer: IntlayerContext }>` typisiert. Zur Laufzeit ist der Wert für alle nach `.use(intlayer())` registrierten Routen immer vorhanden — verwenden Sie daher die Non-Null-Assertion (`intlayer!.locale`) oder Optional Chaining, um TypeScript im `strict`-Modus zufriedenzustellen.
+
+## Zugehörige Dokumentation
+
+- [Elysia i18n - Vollständiger Leitfaden zum Übersetzen deiner App](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_with_elysia.md)
+- [Konfiguration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md)

package/docs/de/packages/elysia-intlayer/intlayer.md

@@ -0,0 +1,139 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: intlayer Elysia Plugin Dokumentation | elysia-intlayer
+description: Erfahren Sie, wie Sie das intlayer-Plugin des elysia-intlayer-Pakets verwenden
+keywords:
+  - intlayer
+  - elysia
+  - plugin
+  - Intlayer
+  - Internationalisierung
+  - Dokumentation
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - intlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Initialisierung der Dokumentation"
+author: aymericzip
+---
+
+# intlayer Elysia Plugin Dokumentation
+
+Das `intlayer`-Plugin für Elysia ermittelt die Locale des Benutzers und injiziert ein `intlayer`-Objekt in den Route-Kontext. Es ermöglicht außerdem die Verwendung globaler Übersetzungsfunktionen innerhalb des Request-Kontexts.
+
+## Verwendung
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", ({ intlayer }) =>
+  intlayer!.t({
+    de: "Hallo",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+> Das Plugin registriert seinen Context über ein **globales** `derive`, das Elysia als `Partial<{ intlayer: IntlayerContext }>` typisiert. Zur Laufzeit ist der Wert für alle nach `.use(intlayer())` registrierten Routen immer vorhanden — verwenden Sie daher die Non-Null-Assertion (`intlayer!.t`) oder Optional Chaining, um TypeScript im `strict`-Modus zufriedenzustellen.
+
+Dieselben Helper stehen auch als eigenständige Exporte zur Verfügung, sodass Sie sie aufrufen können, ohne den Route-Kontext zu destrukturieren:
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer, t } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", () =>
+  t({
+    de: "Hallo",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+## Beschreibung
+
+Das Plugin führt die folgenden Aufgaben aus:
+
+1. **Locale-Erkennung**: Es liest die vom Client explizit gesetzte Locale aus dem Storage (Cookie, Header) und greift anschließend auf die aus dem `Accept-Language`-Header ausgehandelte Locale zurück.
+2. **Kontext-Injektion**: Es fügt dem Elysia-Route-Context eine `intlayer`-Eigenschaft hinzu (siehe die Tabelle Route-Context weiter unten).
+3. **Kontextverwaltung**: Es verwendet `AsyncLocalStorage`, um einen asynchronen Kontext zu verwalten, wodurch die globalen Intlayer-Funktionen (`t`, `getIntlayer`, `getDictionary`) auf die anfragebezogene Locale zugreifen können, ohne das Kontextobjekt weiterreichen zu müssen.
+4. **Vorbereitung der Dictionaries**: Es ruft `prepareIntlayer` beim Erstellen des Plugins auf, sodass die Dictionaries beim Start der Anwendung gebaut werden.
+
+### Route-Context
+
+| Eigenschaft       | Typ                    | Beschreibung                                                                                           |
+| ----------------- | ---------------------- | ------------------------------------------------------------------------------------------------------ |
+| `locale`          | `Locale`               | Die für diese Anfrage zu verwendende Locale, wobei `locale_storage` Vorrang vor `locale_detected` hat. |
+| `locale_storage`  | `Locale` (optional)    | Die vom Client über ein Cookie oder einen Header explizit angeforderte Locale.                         |
+| `locale_detected` | `Locale`               | Die aus den Request-Headern ausgehandelte Locale.                                                      |
+| `defaultLocale`   | `Locale`               | Die in `intlayer.config.ts` als Fallback konfigurierte Locale.                                         |
+| `t`               | `TranslateFunction`    | Eine Übersetzungsfunktion.                                                                             |
+| `getIntlayer`     | `typeof getIntlayer`   | Eine Funktion zum Abrufen von Wörterbüchern anhand ihres Schlüssels.                                   |
+| `getDictionary`   | `typeof getDictionary` | Eine Funktion zum Verarbeiten von Wörterbuchobjekten.                                                  |
+
+> Anders als die Node-basierten Intlayer-Plugins setzt `elysia-intlayer` auf `AsyncLocalStorage` statt auf `cls-hooked`, da `cls-hooked` von `async_hooks.createHook` abhängt, das Bun nicht implementiert.
+
+Der Request-Kontext wird freigegeben, sobald die Response gemappt wurde, sodass die eigenständigen Helper niemals gegen eine bereits beendete Anfrage auflösen. Werden sie außerhalb einer vom Plugin behandelten Anfrage aufgerufen, greifen sie auf die konfigurierte Standard-Locale zurück.
+
+## Reihenfolge der Locale-Auflösung
+
+Standardmäßig löst das Plugin die Locale in dieser Reihenfolge auf:
+
+1. Das Cookie `INTLAYER_LOCALE`.
+2. Der Header `x-intlayer-locale`.
+3. Die Aushandlung über den `Accept-Language`-Header.
+4. Die konfigurierte `defaultLocale`.
+
+```bash
+# Aus `Accept-Language` ausgehandelt
+curl -H "Accept-Language: fr" http://localhost:3000/
+# Bonjour
+
+# Das Cookie hat Vorrang vor `Accept-Language`
+curl -H "Accept-Language: fr" -H "Cookie: INTLAYER_LOCALE=es" http://localhost:3000/
+# Hola
+
+# Der Header hat Vorrang vor `Accept-Language`
+curl -H "Accept-Language: fr" -H "x-intlayer-locale: es" http://localhost:3000/
+# Hola
+```
+
+## Konfiguration
+
+Das Plugin liest Ihre `intlayer.config.ts`-Datei. Sie können das Cookie und den Header anpassen, die für die Locale-Erkennung verwendet werden:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  routing: {
+    storage: [
+      { type: "header", name: "my-locale-header" },
+      { type: "cookie", name: "my-locale-cookie" },
+    ],
+  },
+};
+
+export default config;
+```
+
+> Weitere Informationen zur Konfiguration finden Sie in der [Konfigurationsdokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md).
+
+## Zugehörige Dokumentation
+
+- [elysia-intlayer Paketdokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/elysia-intlayer/exports.md)
+- [Elysia i18n - Vollständiger Leitfaden zum Übersetzen deiner App](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_with_elysia.md)

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>`