@intlayer/docs 5.5.10 → 5.5.11

package/docs/de/packages/react-intlayer/useIntlayerAsync.md

@@ -0,0 +1,256 @@
+---
+createdAt: 2024-08-11
+updatedAt: 2025-06-29
+title: useIntlayerAsync Hook Dokumentation | react-intlayer
+description: Siehe, wie der useIntlayerAsync Hook für das react-intlayer Paket verwendet wird
+keywords:
+  - useIntlayerAsync
+  - Wörterbuch
+  - Schlüssel
+  - Intlayer
+  - Internationalisierung
+  - Dokumentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - react-intlayer
+  - useIntlayerAsync
+---
+
+# React-Integration: `useIntlayerAsync` Hook Dokumentation
+
+Der `useIntlayerAsync` Hook erweitert die Funktionalität von `useIntlayer`, indem er nicht nur vorgerenderte Wörterbücher zurückgibt, sondern auch Updates asynchron abruft. Dadurch ist er ideal für Anwendungen, die ihren lokalisierten Inhalt nach dem ersten Rendern häufig aktualisieren.
+
+## Überblick
+
+- **Asynchrones Laden von Wörterbüchern:**  
+  Beim ersten Mount gibt `useIntlayerAsync` zunächst ein vorab geladenes oder statisch eingebundenes lokales Wörterbuch zurück (genau wie `useIntlayer`) und lädt dann asynchron alle neu verfügbaren entfernten Wörterbücher nach und fügt sie zusammen.
+- **Statusverwaltung des Ladevorgangs:**  
+  Der Hook stellt außerdem einen `isLoading`-Status bereit, der anzeigt, wann ein entferntes Wörterbuch geladen wird. Dies ermöglicht es Entwicklern, Ladeanzeigen oder Skeleton-Zustände für eine flüssigere Benutzererfahrung anzuzeigen.
+
+## Einrichtung der Umgebung
+
+Intlayer bietet ein kopfloses Content Source Management (CSM)-System, das es Nicht-Entwicklern ermöglicht, Anwendungsinhalte nahtlos zu verwalten und zu aktualisieren. Durch die Verwendung des intuitiven Dashboards von Intlayer kann Ihr Team lokalisierten Text, Bilder und andere Ressourcen bearbeiten, ohne direkt den Code ändern zu müssen. Dies vereinfacht den Content-Management-Prozess, fördert die Zusammenarbeit und stellt sicher, dass Aktualisierungen schnell und einfach vorgenommen werden können.
+
+Um mit Intlayer zu starten:
+
+1. **Registrieren Sie sich und erhalten Sie einen Zugriffstoken** unter [https://intlayer.org/dashboard](https://intlayer.org/dashboard).
+2. **Fügen Sie die Zugangsdaten zu Ihrer Konfigurationsdatei hinzu:**  
+   Konfigurieren Sie in Ihrem React-Projekt den Intlayer-Client mit Ihren Zugangsdaten:
+
+   ```typescript fileName="intlayer.config.ts" codeFormat="typescript"
+   import type { IntlayerConfig } from "intlayer";
+
+   export default {
+     // ...
+     editor: {
+       clientId: process.env.INTLAYER_CLIENT_ID,
+       clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+     },
+   } satisfies IntlayerConfig;
+   ```
+
+   ```javascript fileName="intlayer.config.mjs" codeFormat="esm"
+   import { type IntlayerConfig } from "intlayer";
+
+   /** @type {import('intlayer').IntlayerConfig} */
+   const config = {
+     // ...
+     editor: {
+       clientId: process.env.INTLAYER_CLIENT_ID,
+       clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+     },
+   };
+
+   export default config;
+   ```
+
+   ```javascript fileName="intlayer.config.cjs" codeFormat="commonjs"
+   /** @type {import('intlayer').IntlayerConfig} */
+   const config = {
+     // ...
+     editor: {
+       clientId: process.env.INTLAYER_CLIENT_ID,
+       clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+     },
+   };
+
+   module.exports = config;
+   ```
+
+3. **Schieben Sie ein neues Sprachwörterbuch zu Intlayer:**
+
+   ```bash
+   npx intlayer dictionary push -d my-first-dictionary-key
+   ```
+
+   Dieser Befehl lädt Ihre anfänglichen Inhaltswörterbücher hoch und macht sie für asynchrones Abrufen und Bearbeiten über die Intlayer-Plattform verfügbar.
+
+## Importieren von `useIntlayerAsync` in React
+
+Importieren Sie in Ihren React-Komponenten `useIntlayerAsync`:
+
+```ts codeFormat="typescript"
+import { useIntlayerAsync } from "react-intlayer";
+```
+
+```js codeFormat="esm"
+import { useIntlayerAsync } from "react-intlayer";
+```
+
+```js codeFormat="commonjs"
+const { useIntlayerAsync } = require("react-intlayer");
+```
+
+## Parameter
+
+1. **`key`**:
+   **Typ**: `DictionaryKeys`
+   Der Wörterbuchschlüssel, der verwendet wird, um den lokalisierten Inhaltsblock zu identifizieren. Dieser Schlüssel sollte in Ihren Inhaltsdeklarationsdateien definiert sein.
+
+2. **`locale`** (optional):
+   **Typ**: `Locales`
+   Die spezifische Locale, auf die Sie abzielen möchten. Wenn ausgelassen, verwendet der Hook die Locale aus dem aktuellen Intlayer-Kontext.
+
+3. **`isRenderEditor`** (optional, Standardwert `true`):
+   **Typ**: `boolean`
+   Bestimmt, ob der Inhalt für die Darstellung mit der Intlayer-Editor-Overlay bereit sein soll. Wenn auf `false` gesetzt, schließen die zurückgegebenen Wörterbuchdaten editor-spezifische Funktionen aus.
+
+## Rückgabewert
+
+Der Hook gibt ein Wörterbuchobjekt zurück, das lokalisierten Inhalt enthält, der durch `key` und `locale` indiziert ist. Es enthält außerdem ein `isLoading`-Boolean, das angibt, ob gerade ein entferntes Wörterbuch geladen wird.
+
+## Beispielhafte Verwendung in einer React-Komponente
+
+```tsx fileName="src/components/ComponentExample.tsx" codeFormat="typescript"
+import { useEffect, type FC } from "react";
+import { useIntlayerAsync } from "react-intlayer";
+
+export const ComponentExample: FC = () => {
+  const { title, description, isLoading } = useIntlayerAsync("async-component");
+
+  useEffect(() => {
+    if (isLoading) {
+      console.log("Inhalt wird geladen...");
+    }
+  }, [isLoading]);
+
+  return (
+    <div>
+      {isLoading ? (
+        <div>
+          <h1>Lädt…</h1>
+          <p>Bitte warten Sie, während der Inhalt aktualisiert wird.</p>
+        </div>
+      ) : (
+        <div>
+          <h1>{title.value}</h1>
+          <p>{description.value}</p>
+        </div>
+      )}
+    </div>
+  );
+};
+```
+
+```jsx fileName="src/components/ComponentExample.mjx" codeFormat="esm"
+import { useEffect } from "react";
+import { useIntlayerAsync } from "react-intlayer";
+
+const ComponentExample = () => {
+  const { title, description, isLoading } = useIntlayerAsync("async-component");
+
+  useEffect(() => {
+    if (isLoading) {
+      console.log("Inhalt wird geladen...");
+    }
+  }, [isLoading]);
+
+  return (
+    <div>
+      {isLoading ? (
+        <div>
+          <h1>Lädt…</h1>
+          <p>Bitte warten Sie, während der Inhalt aktualisiert wird.</p>
+        </div>
+      ) : (
+        <div>
+          <h1>{title.value}</h1>
+          <p>{description.value}</p>
+        </div>
+      )}
+    </div>
+  );
+};
+```
+
+```jsx fileName="src/components/ComponentExample.csx" codeFormat="commonjs"
+const { useEffect } = require("react");
+const { useIntlayerAsync } = require("react-intlayer");
+
+const ComponentExample = () => {
+  const { title, description, isLoading } = useIntlayerAsync("async-component");
+
+  useEffect(() => {
+    if (isLoading) {
+      console.log("Inhalt wird geladen...");
+    }
+  }, [isLoading]);
+
+  return (
+    <div>
+      {isLoading ? (
+        <div>
+          <h1>Lädt…</h1>
+          <p>Bitte warten Sie, während der Inhalt aktualisiert wird.</p>
+        </div>
+      ) : (
+        <div>
+          <h1>{title.value}</h1>
+          <p>{description.value}</p>
+        </div>
+      )}
+    </div>
+  );
+};
+```
+
+**Wichtige Punkte:**
+
+- Beim ersten Rendern stammen `title` und `description` aus dem vorab geladenen oder statisch eingebetteten Lokalisierungswörterbuch.
+- Solange `isLoading` auf `true` gesetzt ist, wird im Hintergrund eine Anfrage ausgeführt, um ein aktualisiertes Wörterbuch abzurufen.
+- Sobald der Abruf abgeschlossen ist, werden `title` und `description` mit dem neuesten Inhalt aktualisiert, und `isLoading` wird wieder auf `false` gesetzt.
+
+## Umgang mit der Attribut-Lokalisierung
+
+Sie können auch lokalisierte Attributwerte für verschiedene HTML-Eigenschaften abrufen (z. B. `alt`, `title`, `aria-label`):
+
+```jsx
+<img src={title.image.src.value} alt={title.image.alt.value} />
+```
+
+## Wörterbuchdateien
+
+Alle Inhalts-Schlüssel müssen in Ihren Inhaltsdeklarationsdateien definiert sein, um Typensicherheit zu gewährleisten und Laufzeitfehler zu vermeiden. Diese Dateien ermöglichen die TypeScript-Validierung, sodass Sie immer auf vorhandene Schlüssel und Sprachen verweisen.
+
+Anleitungen zum Einrichten von Inhaltsdeklarationsdateien sind [hier](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/get_started.md) verfügbar.
+
+## Weitere Informationen
+
+- **Intlayer Visual Editor:**
+  Integration mit dem Intlayer Visual Editor zur Verwaltung und Bearbeitung von Inhalten direkt über die Benutzeroberfläche. Weitere Details [hier](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_visual_editor.md).
+
+---
+
+**Zusammenfassung**, `useIntlayerAsync` ist ein leistungsstarker React-Hook, der entwickelt wurde, um die Benutzererfahrung zu verbessern und die Aktualität der Inhalte zu gewährleisten, indem vorgerenderte oder vorab geladene Wörterbücher mit asynchronen Wörterbuchaktualisierungen zusammengeführt werden. Durch die Nutzung von `isLoading` und TypeScript-basierten Inhaltsdeklarationen können Sie dynamische, lokalisierte Inhalte nahtlos in Ihre React-Anwendungen integrieren.
+
+## Dokumentationsverlauf
+
+- 5.5.10 - 2025-06-29: Historie initialisiert
+
+```
+
+```

package/docs/de/packages/react-intlayer/useLocale.md

@@ -0,0 +1,210 @@
+---
+createdAt: 2024-08-11
+updatedAt: 2025-06-29
+title: useLocale Hook Dokumentation | react-intlayer
+description: Siehe, wie der useLocale Hook für das react-intlayer Paket verwendet wird
+keywords:
+  - useLocale
+  - Wörterbuch
+  - Schlüssel
+  - Intlayer
+  - Internationalisierung
+  - Dokumentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - react-intlayer
+  - useLocale
+---
+
+# React-Integration: `useLocale` Hook Dokumentation
+
+Dieser Abschnitt bietet umfassende Details zum `useLocale` Hook aus der `react-intlayer` Bibliothek, der für die Verwaltung von Locale-Einstellungen in React-Anwendungen entwickelt wurde.
+
+## Importieren von `useLocale` in React
+
+Um den `useLocale` Hook in Ihre React-Anwendung zu integrieren, importieren Sie ihn aus dem entsprechenden Paket:
+
+```typescript codeFormat="typescript"
+import { useLocale } from "react-intlayer"; // Wird in React-Komponenten zur Verwaltung der Locale verwendet
+```
+
+```javascript codeFormat="esm"
+import { useLocale } from "react-intlayer"; // Wird in React-Komponenten zur Verwaltung der Locale verwendet
+```
+
+```javascript codeFormat="commonjs"
+const { useLocale } = require("react-intlayer"); // Wird in React-Komponenten zur Verwaltung der Locale verwendet
+```
+
+## Überblick
+
+Der `useLocale` Hook bietet eine einfache Möglichkeit, auf die Locale-Einstellungen innerhalb von React-Komponenten zuzugreifen und diese zu manipulieren. Er stellt Zugriff auf die aktuelle Locale, die Standard-Locale, alle verfügbaren Locales sowie Funktionen zur Aktualisierung der Locale-Einstellungen bereit.
+
+## Verwendung
+
+So können Sie den `useLocale` Hook innerhalb einer React-Komponente verwenden:
+
+```tsx fileName="src/components/LocaleSwitcher.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useLocale } from "react-intlayer";
+
+const LocaleSwitcher: FC = () => {
+  const { locale, defaultLocale, availableLocales, setLocale } = useLocale();
+
+  return (
+    <div>
+      <h1>Aktuelle Locale: {locale}</h1>
+      <p>Standard-Locale: {defaultLocale}</p>
+      <select value={locale} onChange={(e) => setLocale(e.target.value)}>
+        {availableLocales.map((loc) => (
+          <option key={loc} value={loc}>
+            {loc}
+          </option>
+        ))}
+      </select>
+    </div>
+  );
+};
+
+export default LocaleSwitcher;
+```
+
+```jsx fileName="src/components/LocaleSwitcher.mjx" codeFormat="esm"
+import { useLocale } from "react-intlayer";
+
+const LocaleSwitcher = () => {
+  const { locale, defaultLocale, availableLocales, setLocale } = useLocale();
+
+  return (
+    <div>
+      <h1>Aktuelle Locale: {locale}</h1>
+      <p>Standard-Locale: {defaultLocale}</p>
+      <select value={locale} onChange={(e) => setLocale(e.target.value)}>
+        {availableLocales.map((loc) => (
+          <option key={loc} value={loc}>
+            {loc}
+          </option>
+        ))}
+      </select>
+    </div>
+  );
+};
+
+export default LocaleSwitcher;
+```
+
+```jsx fileName="src/components/LocaleSwitcher.csx" codeFormat="commonjs"
+const { useLocale } = require("react-intlayer");
+
+const LocaleSwitcher = () => {
+  const { locale, defaultLocale, availableLocales, setLocale } = useLocale();
+
+  return (
+    <div>
+      <h1>Aktuelle Locale: {locale}</h1>
+      <p>Standard-Locale: {defaultLocale}</p>
+      <select value={locale} onChange={(e) => setLocale(e.target.value)}>
+        {availableLocales.map((loc) => (
+          <option key={loc} value={loc}>
+            {loc}
+          </option>
+        ))}
+      </select>
+    </div>
+  );
+};
+
+export default LocaleSwitcher;
+```
+
+## Parameter und Rückgabewerte
+
+Wenn Sie den `useLocale` Hook aufrufen, gibt dieser ein Objekt mit den folgenden Eigenschaften zurück:
+
+- **`locale`**: Die aktuelle Locale, wie sie im React-Kontext gesetzt ist.
+- **`defaultLocale`**: Die primäre Locale, die in der Konfiguration definiert ist.
+- **`availableLocales`**: Eine Liste aller verfügbaren Locales, wie sie in der Konfiguration definiert sind.
+- **`setLocale`**: Eine Funktion, um die aktuelle Locale im Kontext der Anwendung zu aktualisieren.
+
+## Beispiel
+
+Dieses Beispiel zeigt eine Komponente, die den `useLocale` Hook verwendet, um einen Locale-Umschalter darzustellen, der es den Benutzern ermöglicht, die Locale der Anwendung dynamisch zu ändern:
+
+```tsx fileName="src/components/LocaleSelector.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useLocale } from "react-intlayer";
+
+const LocaleSelector: FC = () => {
+  const { locale, setLocale, availableLocales } = useLocale();
+
+  const handleLocaleChange = (newLocale) => {
+    setLocale(newLocale);
+  };
+
+  return (
+    <select value={locale} onChange={(e) => handleLocaleChange(e.target.value)}>
+      {availableLocales.map((locale) => (
+        <option key={locale} value={locale}>
+          {locale}
+        </option>
+      ))}
+    </select>
+  );
+};
+```
+
+```jsx fileName="src/components/LocaleSelector.mjx" codeFormat="esm"
+import { useLocale } from "react-intlayer";
+
+const LocaleSelector = () => {
+  const { locale, setLocale, availableLocales } = useLocale();
+
+  const handleLocaleChange = (newLocale) => {
+    setLocale(newLocale);
+  };
+
+  return (
+    <select value={locale} onChange={(e) => handleLocaleChange(e.target.value)}>
+      {availableLocales.map((locale) => (
+        <option key={locale} value={locale}>
+          {locale}
+        </option>
+      ))}
+    </select>
+  );
+};
+```
+
+```jsx fileName="src/components/LocaleSelector.csx" codeFormat="commonjs"
+const { useLocale } = require("react-intlayer");
+
+const LocaleSelector = () => {
+  const { locale, setLocale, availableLocales } = useLocale();
+
+  const handleLocaleChange = (newLocale) => {
+    setLocale(newLocale);
+  };
+
+  return (
+    <select value={locale} onChange={(e) => handleLocaleChange(e.target.value)}>
+      {availableLocales.map((locale) => (
+        <option key={locale} value={locale}>
+          {locale}
+        </option>
+      ))}
+    </select>
+  );
+};
+```
+
+## Fazit
+
+Der `useLocale` Hook von `react-intlayer` ist ein unverzichtbares Werkzeug zur Verwaltung von Sprach- und Ländereinstellungen in Ihren React-Anwendungen und bietet die notwendige Funktionalität, um Ihre Anwendung effektiv an verschiedene internationale Zielgruppen anzupassen.
+
+## Dokumentationshistorie
+
+- 5.5.10 - 2025-06-29: Initiale Historie

package/docs/de/packages/react-native-intlayer/index.md

@@ -0,0 +1,83 @@
+---
+createdAt: 2025-03-13
+updatedAt: 2025-06-29
+title: Paketdokumentation | react-native-intlayer
+description: Siehe, wie man das react-native-intlayer Paket verwendet
+keywords:
+  - Intlayer
+  - React Native
+  - react-native-intlayer
+  - Internationalisierung
+  - Dokumentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - react-native-intlayer
+---
+
+# react-native-intlayer: Internationalisieren (i18n) einer React Native Anwendung
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurden. Es ist kompatibel mit Frameworks wie React, React und Express.js.
+
+**Das `react-native-intlayer` Paket** ermöglicht es Ihnen, Ihre Vite-Anwendung zu internationalisieren. Es beinhaltet das Metro-Plugin, um die Konfiguration über Umgebungsvariablen im [Metro Bundler](https://docs.expo.dev/guides/customizing-metro/) festzulegen.
+
+## Warum sollten Sie Ihre React Native Anwendung internationalisieren?
+
+Die Internationalisierung Ihrer React Native Anwendung ist entscheidend, um ein globales Publikum effektiv zu bedienen. Sie ermöglicht es Ihrer Anwendung, Inhalte und Nachrichten in der bevorzugten Sprache jedes Nutzers bereitzustellen. Diese Fähigkeit verbessert die Benutzererfahrung und erweitert die Reichweite Ihrer Anwendung, indem sie für Menschen aus verschiedenen sprachlichen Hintergründen zugänglicher und relevanter wird.
+
+## Konfiguration
+
+Das `react-native-intlayer` Paket arbeitet nahtlos mit dem [`react-intlayer` Paket](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/react-intlayer/index.md) und dem [`intlayer` Paket](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/index.md) zusammen. Schauen Sie sich die entsprechende Dokumentation für weitere Informationen an.
+
+## Installation
+
+Installieren Sie das notwendige Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install react-native-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add react-native-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add react-native-intlayer
+```
+
+## Anwendungsbeispiel
+
+Sehen Sie ein Beispiel, wie Sie die Plugins in Ihre Vite-Konfiguration einbinden.
+
+```js
+// metro.config.js
+const { getDefaultConfig } = require("expo/metro-config");
+const { configMetroIntlayer } = require("react-native-intlayer/metro");
+
+module.exports = (async () => {
+  const defaultConfig = getDefaultConfig(__dirname);
+
+  return await configMetroIntlayer(defaultConfig);
+})();
+```
+
+## Die Internationalisierung Ihrer Vite-Anwendung meistern
+
+Intlayer bietet viele Funktionen, die Ihnen helfen, Ihre Vite-Anwendung zu internationalisieren.
+
+**Um mehr über diese Funktionen zu erfahren, lesen Sie den Leitfaden [React Internationalization (i18n) mit Intlayer und React Native](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_with_react_native+expo.md) für React Native Anwendungen.**
+
+## Mehr über Intlayer erfahren
+
+- [Intlayer Webseite](https://intlayer.org)
+- [Intlayer Dokumentation](https://intlayer.org/doc)
+- [Intlayer GitHub](https://github.com/aymericzip/intlayer)
+
+- [Stellen Sie Ihre Fragen an unsere intelligente Dokumentation](https://intlayer.org/docchat)
+
+## Dokumentationsverlauf
+
+- 5.5.10 - 2025-06-29: Initiale Historie

package/docs/de/packages/react-scripts-intlayer/index.md

@@ -0,0 +1,80 @@
+---
+createdAt: 2024-08-11
+updatedAt: 2025-06-29
+title: Paketdokumentation | react-scripts-intlayer
+description: Siehe, wie das react-scripts-intlayer Paket verwendet wird
+keywords:
+  - Intlayer
+  - react-scripts-intlayer
+  - Internationalisierung
+  - Dokumentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - react-scripts-intlayer
+---
+
+# react-scripts-intlayer: NPM-Paket zur Verwendung von Intlayer in einer React Create App-Anwendung
+
+**Intlayer** ist eine Sammlung von Paketen, die speziell für JavaScript-Entwickler entwickelt wurden. Es ist kompatibel mit Frameworks wie React, React und Express.js.
+
+**Das `react-scripts-intlayer` Paket** beinhaltet die `react-scripts-intlayer` Befehle und Plugins zur Integration von Intlayer in eine auf Create React App basierende Anwendung. Diese Plugins basieren auf [craco](https://craco.js.org/) und enthalten zusätzliche Konfigurationen für den [Webpack](https://webpack.js.org/) Bundler.
+
+## Konfiguration
+
+Das `react-scripts-intlayer` Paket arbeitet nahtlos mit dem [`react-intlayer` Paket](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/react-intlayer/index.md) und dem [`intlayer` Paket](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/index.md) zusammen. Siehe die entsprechende Dokumentation für weitere Informationen.
+
+## Installation
+
+Installieren Sie das notwendige Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install react-scripts-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add react-scripts-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add react-scripts-intlayer
+```
+
+## Verwendung
+
+### CLI-Befehle
+
+Das `react-scripts-intlayer` Paket stellt die folgenden CLI-Befehle bereit:
+
+- `npx react-scripts-intlayer build`: Baut die React-Anwendung mit der Intlayer-Konfiguration.
+- `npx react-scripts-intlayer start`: Startet den Entwicklungsserver mit der Intlayer-Konfiguration.
+
+### Ersetzen der package.json Skripte
+
+Um das `react-scripts-intlayer` Paket zu verwenden, müssen Sie die Skripte in der `package.json` durch die folgenden Befehle ersetzen:
+
+```json fileName="package.json"
+{
+  "scripts": {
+    "start": "react-scripts-intlayer start",
+    "build": "react-scripts-intlayer build"
+  }
+}
+```
+
+## Benutzerdefinierte Webpack-Konfiguration verwenden
+
+`react-scripts-intlayer` basiert auf [craco](https://craco.js.org/), das es Ihnen ermöglicht, die Webpack-Konfiguration anzupassen.
+Wenn Sie die Webpack-Konfiguration anpassen müssen, können Sie auch Ihre eigene Einrichtung basierend auf dem intlayer craco Plugin implementieren. [Siehe Beispiel hier](https://github.com/aymericzip/intlayer/blob/main/examples/react-app/craco.config.js).
+
+## Lesen Sie die vollständige Intlayer-Anleitung für React Create App
+
+Intlayer bietet viele Funktionen, um Ihnen bei der Internationalisierung Ihrer React-Anwendung zu helfen.
+[Siehe, wie man intlayer mit React Create App verwendet](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_with_create_react_app.md).
+
+## Dokumentationsverlauf
+
+- 5.5.10 - 2025-06-29: Initialer Verlauf

package/docs/de/packages/solid-intlayer/index.md

@@ -0,0 +1,54 @@
+---
+createdAt: 2024-08-11
+updatedAt: 2025-06-29
+title: Paketdokumentation | solid-intlayer
+description: Siehe, wie man das solid-intlayer-Paket verwendet
+keywords:
+  - Intlayer
+  - solid-intlayer
+  - Internationalisierung
+  - Dokumentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - solid-intlayer
+---
+
+# solid-intlayer: NPM-Paket zur Internationalisierung (i18n) einer Solid-Anwendung
+
+**Intlayer** ist eine Sammlung von Paketen, die speziell für JavaScript-Entwickler entwickelt wurden. Es ist kompatibel mit Frameworks wie Solid, Solid und Express.js.
+
+**Das `solid-intlayer`-Paket** ermöglicht es Ihnen, Ihre Solid-Anwendung zu internationalisieren. Es stellt Kontextanbieter und Hooks für die Internationalisierung von Solid bereit.
+
+## Warum sollten Sie Ihre Solid-Anwendung internationalisieren?
+
+Die Internationalisierung Ihrer Solid-Anwendung ist entscheidend, um ein globales Publikum effektiv zu bedienen. Sie ermöglicht es Ihrer Anwendung, Inhalte und Nachrichten in der bevorzugten Sprache jedes Benutzers bereitzustellen. Diese Fähigkeit verbessert die Benutzererfahrung und erweitert die Reichweite Ihrer Anwendung, indem sie für Menschen aus verschiedenen sprachlichen Hintergründen zugänglicher und relevanter wird.
+
+## Warum Intlayer integrieren?
+
+- **JavaScript-gesteuertes Content-Management**: Nutzen Sie die Flexibilität von JavaScript, um Ihre Inhalte effizient zu definieren und zu verwalten.
+- **Typensicheres Umfeld**: Nutzen Sie TypeScript, um sicherzustellen, dass alle Ihre Inhaltsdefinitionen präzise und fehlerfrei sind.
+- **Integrierte Inhaltsdateien**: Halten Sie Ihre Übersetzungen nahe bei den jeweiligen Komponenten, um Wartbarkeit und Übersichtlichkeit zu verbessern.
+
+## Installation
+
+Installieren Sie das erforderliche Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install solid-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add solid-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add solid-intlayer
+```
+
+## Dokumentationshistorie
+
+- 5.5.10 - 2025-06-29: Initiale Historie