@intlayer/docs 5.5.8

package/de/dictionary/condition.md

@@ -0,0 +1,213 @@
+# Bedingter Inhalt / Bedingung in Intlayer
+
+## Wie Bedingung funktioniert
+
+In Intlayer wird bedingter Inhalt durch die `cond`-Funktion erreicht, die spezifische Bedingungen (typischerweise boolesche Werte) ihren entsprechenden Inhalten zuordnet. Dieser Ansatz ermöglicht es Ihnen, Inhalte dynamisch basierend auf einer gegebenen Bedingung auszuwählen. Wenn es mit React Intlayer oder Next Intlayer integriert ist, wird der entsprechende Inhalt automatisch gemäß der zur Laufzeit bereitgestellten Bedingung ausgewählt.
+
+## Einrichten von bedingtem Inhalt
+
+Um bedingten Inhalt in Ihrem Intlayer-Projekt einzurichten, erstellen Sie ein Inhaltsmodul, das Ihre bedingten Definitionen enthält. Nachfolgend finden Sie Beispiele in verschiedenen Formaten.
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { cond, type Dictionary } from "intlayer";
+
+const myConditionalContent = {
+  key: "my_key",
+  content: {
+    myCondition: cond({
+      true: "mein Inhalt, wenn es wahr ist",
+      false: "mein Inhalt, wenn es falsch ist",
+      fallback: "mein Inhalt, wenn die Bedingung fehlschlägt", // Optional
+    }),
+  },
+} satisfies Dictionary;
+
+export default myConditionalContent;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { cond } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+const myConditionalContent = {
+  key: "my_key",
+  content: {
+    myCondition: cond({
+      true: "mein Inhalt, wenn es wahr ist",
+      false: "mein Inhalt, wenn es falsch ist",
+      fallback: "mein Inhalt, wenn die Bedingung fehlschlägt", // Optional
+    }),
+  },
+};
+
+export default myConditionalContent;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { cond } = require("intlayer");
+
+/** @type {import('intlayer').Dictionary} */
+const myConditionalContent = {
+  key: "my_key",
+  content: {
+    myCondition: cond({
+      true: "mein Inhalt, wenn es wahr ist",
+      false: "mein Inhalt, wenn es falsch ist",
+      fallback: "mein Inhalt, wenn die Bedingung fehlschlägt", // Optional
+    }),
+  },
+};
+
+module.exports = myConditionalContent;
+```
+
+```json5 fileName="**/*.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "my_key",
+  "content": {
+    "myCondition": {
+      "nodeType": "condition",
+      "condition": {
+        "true": "mein Inhalt, wenn es wahr ist",
+        "false": "mein Inhalt, wenn es falsch ist",
+        "fallback": "mein Inhalt, wenn die Bedingung fehlschlägt", // Optional
+      },
+    },
+  },
+}
+```
+
+> Wenn kein Fallback deklariert ist, wird der zuletzt deklarierte Schlüssel als Fallback verwendet, falls die Bedingung nicht erfüllt ist.
+
+## Verwendung von bedingtem Inhalt mit React Intlayer
+
+Um bedingten Inhalt innerhalb einer React-Komponente zu verwenden, importieren und nutzen Sie den `useIntlayer`-Hook aus dem `react-intlayer`-Paket. Dieser Hook ruft den Inhalt für den angegebenen Schlüssel ab und ermöglicht es Ihnen, eine Bedingung zu übergeben, um die entsprechende Ausgabe auszuwählen.
+
+```tsx fileName="**/*.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const ConditionalComponent: FC = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn es wahr ist */
+          myCondition(true)
+        }
+      </p>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn es falsch ist */
+          myCondition(false)
+        }
+      </p>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn die Bedingung fehlschlägt */
+          myCondition("")
+        }
+      </p>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn die Bedingung fehlschlägt */
+          myCondition(undefined)
+        }
+      </p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+```javascript fileName="**/*.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const ConditionalComponent = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn es wahr ist */
+          myCondition(true)
+        }
+      </p>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn es falsch ist */
+          myCondition(false)
+        }
+      </p>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn die Bedingung fehlschlägt */
+          myCondition("")
+        }
+      </p>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn die Bedingung fehlschlägt */
+          myCondition(undefined)
+        }
+      </p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+```javascript fileName="**/*.cjs" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const ConditionalComponent = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn es wahr ist */
+          myCondition(true)
+        }
+      </p>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn es falsch ist */
+          myCondition(false)
+        }
+      </p>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn die Bedingung fehlschlägt */
+          myCondition("")
+        }
+      </p>
+      <p>
+        {
+          /* Ausgabe: mein Inhalt, wenn die Bedingung fehlschlägt */
+          myCondition(undefined)
+        }
+      </p>
+    </div>
+  );
+};
+
+module.exports = ConditionalComponent;
+```
+
+## Zusätzliche Ressourcen
+
+Für detailliertere Informationen zur Konfiguration und Nutzung finden Sie in den folgenden Ressourcen:
+
+- [Intlayer CLI Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_cli.md)
+- [React Intlayer Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_create_react_app.md)
+- [Next Intlayer Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_nextjs_15.md)
+
+Diese Ressourcen bieten weitere Einblicke in die Einrichtung und Nutzung von Intlayer in verschiedenen Umgebungen und Frameworks.

package/de/dictionary/content_extention_customization.md

@@ -0,0 +1,81 @@
+# Inhaltsanpassung der Erweiterung
+
+## Inhaltsdateierweiterungen
+
+Intlayer ermöglicht es Ihnen, die Erweiterungen für Ihre Inhaltsdeklarationsdateien anzupassen. Diese Anpassung bietet Flexibilität bei der Verwaltung von Großprojekten und hilft, Konflikte mit anderen Modulen zu vermeiden.
+
+### Standarderweiterungen
+
+Standardmäßig überwacht Intlayer alle Dateien mit den folgenden Erweiterungen für Inhaltsdeklarationen:
+
+- `.content.json`
+- `.content.ts`
+- `.content.tsx`
+- `.content.js`
+- `.content.jsx`
+- `.content.mjs`
+- `.content.mjx`
+- `.content.cjs`
+- `.content.cjx`
+
+Diese Standarderweiterungen sind für die meisten Anwendungen geeignet. Wenn Sie jedoch spezifische Anforderungen haben, können Sie benutzerdefinierte Erweiterungen definieren, um den Build-Prozess zu optimieren und das Risiko von Konflikten mit anderen Komponenten zu minimieren.
+
+### Anpassung der Inhaltserweiterungen
+
+Um die Dateierweiterungen anzupassen, die Intlayer zur Identifizierung von Inhaltsdeklarationsdateien verwendet, können Sie diese in der Intlayer-Konfigurationsdatei angeben. Dieser Ansatz ist besonders vorteilhaft für Großprojekte, bei denen die Einschränkung des Überwachungsbereichs die Build-Leistung verbessert.
+
+Hier ist ein Beispiel, wie Sie benutzerdefinierte Inhaltserweiterungen in Ihrer Konfiguration definieren können:
+
+```typescript fileName="intlayer.config.ts" codeFormat="typescript"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  content: {
+    fileExtensions: [".my_content.ts", ".my_content.tsx"], // Ihre benutzerdefinierten Erweiterungen
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.mjs" codeFormat="esm"
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  content: {
+    fileExtensions: [".my_content.cjs", ".my_content.cjx"], // Ihre benutzerdefinierten Erweiterungen
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.cjs" codeFormat="commonjs"
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  content: {
+    fileExtensions: [".my_content.mjs", ".my_content.mjx"], // Ihre benutzerdefinierten Erweiterungen
+  },
+};
+
+module.exports = config;
+```
+
+In diesem Beispiel gibt die Konfiguration zwei benutzerdefinierte Erweiterungen an: `.my_content.ts` und `.my_content.tsx`. Intlayer überwacht nur Dateien mit diesen Erweiterungen, um Wörterbücher zu erstellen.
+
+### Vorteile benutzerdefinierter Erweiterungen
+
+- **Build-Leistung**: Die Einschränkung des Überwachungsbereichs kann die Build-Leistung in großen Projekten erheblich verbessern.
+- **Konfliktvermeidung**: Benutzerdefinierte Erweiterungen helfen, Konflikte mit anderen JavaScript- oder TypeScript-Dateien in Ihrem Projekt zu vermeiden.
+- **Organisation**: Benutzerdefinierte Erweiterungen ermöglichen es Ihnen, Ihre Inhaltsdeklarationsdateien entsprechend den Anforderungen Ihres Projekts zu organisieren.
+
+### Richtlinien für benutzerdefinierte Erweiterungen
+
+Bei der Anpassung von Inhaltsdateierweiterungen sollten Sie die folgenden Richtlinien beachten:
+
+- **Einzigartigkeit**: Wählen Sie Erweiterungen, die innerhalb Ihres Projekts einzigartig sind, um Konflikte zu vermeiden.
+- **Konsistente Benennung**: Verwenden Sie konsistente Benennungskonventionen für eine bessere Lesbarkeit und Wartung des Codes.
+- **Vermeidung gängiger Erweiterungen**: Verzichten Sie auf die Verwendung gängiger Erweiterungen wie `.ts` oder `.js`, um Konflikte mit anderen Modulen oder Bibliotheken zu vermeiden.
+
+## Fazit
+
+Die Anpassung von Inhaltsdateierweiterungen in Intlayer ist eine wertvolle Funktion zur Optimierung der Leistung und Vermeidung von Konflikten in groß angelegten Anwendungen. Durch die Befolgung der in dieser Dokumentation beschriebenen Richtlinien können Sie Ihre Inhaltsdeklarationen effektiv verwalten und eine reibungslose Integration mit anderen Teilen Ihres Projekts sicherstellen.

package/de/dictionary/enumeration.md

@@ -0,0 +1,221 @@
+# Enumeration / Pluralisierung
+
+## Wie Enumeration funktioniert
+
+In Intlayer wird die Enumeration durch die `enu`-Funktion erreicht, die spezifische Schlüssel ihren entsprechenden Inhalten zuordnet. Diese Schlüssel können numerische Werte, Bereiche oder benutzerdefinierte Bezeichner darstellen. Bei Verwendung mit React Intlayer oder Next Intlayer wird der passende Inhalt automatisch basierend auf der Anwendungslokalisierung und definierten Regeln ausgewählt.
+
+## Einrichtung der Enumeration
+
+Um die Enumeration in Ihrem Intlayer-Projekt einzurichten, müssen Sie ein Inhaltsmodul erstellen, das Enumerationsdefinitionen enthält. Hier ist ein Beispiel für eine einfache Enumeration für die Anzahl der Autos:
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { enu, type Dictionary } from "intlayer";
+
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Weniger als minus ein Auto",
+      "-1": "Minus ein Auto",
+      "0": "Keine Autos",
+      "1": "Ein Auto",
+      ">5": "Einige Autos",
+      ">19": "Viele Autos",
+      "fallback": "Fallback-Wert", // Optional
+    }),
+  },
+} satisfies Dictionary;
+
+export default carEnumeration;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { enu } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Weniger als minus ein Auto",
+      "-1": "Minus ein Auto",
+      "0": "Keine Autos",
+      "1": "Ein Auto",
+      ">5": "Einige Autos",
+      ">19": "Viele Autos",
+      "fallback": "Fallback-Wert", // Optional
+    }),
+  },
+};
+
+export default carEnumeration;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { enu } = require("intlayer");
+
+/** @type {import('intlayer').Dictionary} */
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Weniger als minus ein Auto",
+      "-1": "Minus ein Auto",
+      "0": "Keine Autos",
+      "1": "Ein Auto",
+      ">5": "Einige Autos",
+      ">19": "Viele Autos",
+      "fallback": "Fallback-Wert", // Optional
+    }),
+  },
+};
+
+module.exports = carEnumeration;
+```
+
+```json fileName="**/*.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "car_count",
+  "content": {
+    "numberOfCar": {
+      "nodeType": "enumeration",
+      "enumeration": {
+        "<-1": "Weniger als minus ein Auto",
+        "-1": "Minus ein Auto",
+        "0": "Keine Autos",
+        "1": "Ein Auto",
+        ">5": "Einige Autos",
+        ">19": "Viele Autos",
+        "fallback": "Fallback-Wert" // Optional
+      }
+    }
+  }
+}
+```
+
+In diesem Beispiel ordnet `enu` verschiedene Bedingungen spezifischen Inhalten zu. Bei Verwendung in einer React-Komponente kann Intlayer automatisch den passenden Inhalt basierend auf der angegebenen Variablen auswählen.
+
+> Die Reihenfolge der Deklaration ist wichtig bei Intlayer-Enumerationen. Die erste gültige Deklaration wird übernommen. Wenn mehrere Bedingungen zutreffen, stellen Sie sicher, dass sie korrekt geordnet sind, um unerwartetes Verhalten zu vermeiden.
+
+> Wenn kein Fallback deklariert ist, gibt die Funktion `undefined` zurück, wenn keine Schlüssel übereinstimmen.
+
+## Verwendung der Enumeration mit React Intlayer
+
+Um Enumeration in einer React-Komponente zu verwenden, können Sie den `useIntlayer`-Hook aus dem `react-intlayer`-Paket nutzen. Dieser Hook ruft den korrekten Inhalt basierend auf der angegebenen ID ab. Hier ist ein Beispiel, wie man ihn verwendet:
+
+```tsx fileName="**/*.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const CarComponent: FC = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Ausgabe: Keine Autos
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Ausgabe: Einige Autos
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Ausgabe: Viele Autos
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Ausgabe: Fallback-Wert
+        }
+      </p>
+    </div>
+  );
+};
+```
+
+```javascript fileName="**/*.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const CarComponent = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Ausgabe: Keine Autos
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Ausgabe: Einige Autos
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Ausgabe: Viele Autos
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Ausgabe: Fallback-Wert
+        }
+      </p>
+    </div>
+  );
+};
+
+export default CarComponent;
+```
+
+```javascript fileName="**/*.cjs" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const CarComponent = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Ausgabe: Keine Autos
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Ausgabe: Einige Autos
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Ausgabe: Viele Autos
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Ausgabe: Fallback-Wert
+        }
+      </p>
+    </div>
+  );
+};
+
+module.exports = CarComponent;
+```
+
+In diesem Beispiel passt die Komponente ihre Ausgabe dynamisch basierend auf der Anzahl der Autos an. Der korrekte Inhalt wird automatisch abhängig vom angegebenen Bereich ausgewählt.
+
+## Zusätzliche Ressourcen
+
+Für detailliertere Informationen zur Konfiguration und Nutzung lesen Sie die folgenden Ressourcen:
+
+- [Intlayer CLI Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_cli.md)
+- [React Intlayer Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_create_react_app.md)
+- [Next Intlayer Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_nextjs_15.md)
+
+Diese Ressourcen bieten weitere Einblicke in die Einrichtung und Nutzung von Intlayer in verschiedenen Umgebungen und mit verschiedenen Frameworks.