@intlayer/docs 5.5.10 → 5.5.11

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

@@ -0,0 +1,252 @@
+---
+createdAt: 2024-08-11
+updatedAt: 2025-06-29
+title: Documentation du Hook useIntlayerAsync | react-intlayer
+description: Découvrez comment utiliser le hook useIntlayerAsync pour le package react-intlayer
+keywords:
+  - useIntlayerAsync
+  - dictionnaire
+  - clé
+  - Intlayer
+  - Internationalisation
+  - Documentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - react-intlayer
+  - useIntlayerAsync
+---
+
+# Intégration React : Documentation du Hook `useIntlayerAsync`
+
+Le hook `useIntlayerAsync` étend la fonctionnalité de `useIntlayer` en ne se contentant pas de retourner des dictionnaires pré-rendus, mais en récupérant également les mises à jour de manière asynchrone, ce qui le rend idéal pour les applications qui mettent fréquemment à jour leur contenu localisé après le rendu initial.
+
+## Vue d'ensemble
+
+- **Chargement asynchrone des dictionnaires :**  
+  Lors du montage initial, `useIntlayerAsync` retourne d'abord tout dictionnaire de locale pré-récupéré ou empaqueté statiquement (tout comme `useIntlayer` le ferait), puis récupère et fusionne de manière asynchrone tout dictionnaire distant nouvellement disponible.
+- **Gestion de l'état de progression :**  
+  Le hook fournit également un état `isLoading`, indiquant lorsqu'un dictionnaire distant est en cours de récupération. Cela permet aux développeurs d'afficher des indicateurs de chargement ou des états de squelette pour une expérience utilisateur plus fluide.
+
+## Configuration de l'environnement
+
+Intlayer fournit un système de gestion de source de contenu (CSM) sans interface (headless) qui permet aux non-développeurs de gérer et de mettre à jour le contenu des applications de manière fluide. En utilisant le tableau de bord intuitif d'Intlayer, votre équipe peut éditer les textes localisés, les images et d'autres ressources sans modifier directement le code. Cela simplifie le processus de gestion de contenu, favorise la collaboration et garantit que les mises à jour peuvent être effectuées rapidement et facilement.
+
+Pour commencer avec Intlayer :
+
+1. **Inscrivez-vous et obtenez un jeton d'accès** sur [https://intlayer.org/dashboard](https://intlayer.org/dashboard).
+2. **Ajoutez les identifiants à votre fichier de configuration :**  
+   Dans votre projet React, configurez le client Intlayer avec vos identifiants :
+
+   ```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. **Pousser un nouveau dictionnaire de langue vers Intlayer :**
+
+   ```bash
+   npx intlayer dictionary push -d my-first-dictionary-key
+   ```
+
+   Cette commande télécharge vos dictionnaires de contenu initiaux, les rendant disponibles pour une récupération et une édition asynchrones via la plateforme Intlayer.
+
+## Importer `useIntlayerAsync` dans React
+
+Dans vos composants React, importez `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");
+```
+
+## Paramètres
+
+1. **`key`** :  
+   **Type** : `DictionaryKeys`  
+   La clé du dictionnaire utilisée pour identifier le bloc de contenu localisé. Cette clé doit être définie dans vos fichiers de déclaration de contenu.
+
+2. **`locale`** (optionnel) :  
+   **Type** : `Locales`  
+   La locale spécifique que vous souhaitez cibler. Si elle est omise, le hook utilise la locale du contexte Intlayer actuel.
+
+3. **`isRenderEditor`** (optionnel, par défaut à `true`) :  
+   **Type** : `boolean`  
+   Détermine si le contenu doit être prêt à être rendu avec la superposition de l'éditeur Intlayer. Si défini à `false`, les données du dictionnaire retournées excluront les fonctionnalités spécifiques à l'éditeur.
+
+## Valeur de retour
+
+Le hook retourne un objet dictionnaire contenant le contenu localisé indexé par `key` et `locale`. Il inclut également un booléen `isLoading` indiquant si un dictionnaire distant est en cours de récupération.
+
+## Exemple d'utilisation dans un composant React
+
+```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("Le contenu est en cours de chargement...");
+    }
+  }, [isLoading]);
+
+  return (
+    <div>
+      {isLoading ? (
+        <div>
+          <h1>Chargement…</h1>
+          <p>Veuillez patienter pendant la mise à jour du contenu.</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("Le contenu est en cours de chargement...");
+    }
+  }, [isLoading]);
+
+  return (
+    <div>
+      {isLoading ? (
+        <div>
+          <h1>Chargement…</h1>
+          <p>Veuillez patienter pendant la mise à jour du contenu.</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("Le contenu est en cours de chargement...");
+    }
+  }, [isLoading]);
+
+  return (
+    <div>
+      {isLoading ? (
+        <div>
+          <h1>Chargement…</h1>
+          <p>Veuillez patienter pendant la mise à jour du contenu.</p>
+        </div>
+      ) : (
+        <div>
+          <h1>{title.value}</h1>
+          <p>{description.value}</p>
+        </div>
+      )}
+    </div>
+  );
+};
+```
+
+**Points clés :**
+
+- Lors du rendu initial, `title` et `description` proviennent du dictionnaire de locale préchargé ou intégré statiquement.
+- Tant que `isLoading` est `true`, une requête en arrière-plan récupère un dictionnaire mis à jour.
+- Une fois la récupération terminée, `title` et `description` sont mis à jour avec le contenu le plus récent, et `isLoading` revient à `false`.
+
+## Gestion de la localisation des attributs
+
+Vous pouvez également récupérer des valeurs localisées pour divers attributs HTML (par exemple, `alt`, `title`, `aria-label`) :
+
+```jsx
+<img src={title.image.src.value} alt={title.image.alt.value} />
+```
+
+## Fichiers de dictionnaire
+
+Toutes les clés de contenu doivent être définies dans vos fichiers de déclaration de contenu pour garantir la sécurité des types et éviter les erreurs à l'exécution. Ces fichiers permettent la validation TypeScript, assurant que vous référencez toujours des clés et des locales existantes.
+
+Les instructions pour configurer les fichiers de déclaration de contenu sont disponibles [ici](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/get_started.md).
+
+## Informations complémentaires
+
+- **Éditeur Visuel Intlayer :**  
+  Intégrez l’éditeur visuel Intlayer pour gérer et éditer le contenu directement depuis l’interface utilisateur. Plus de détails [ici](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_visual_editor.md).
+
+---
+
+**En résumé**, `useIntlayerAsync` est un hook React puissant conçu pour améliorer l'expérience utilisateur et maintenir la fraîcheur du contenu en fusionnant des dictionnaires pré-rendus ou pré-récupérés avec des mises à jour asynchrones des dictionnaires. En tirant parti de `isLoading` et des déclarations de contenu basées sur TypeScript, vous pouvez intégrer de manière transparente un contenu dynamique et localisé dans vos applications React.
+
+## Historique de la documentation
+
+- 5.5.10 - 2025-06-29 : Historique initial

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

@@ -0,0 +1,210 @@
+---
+createdAt: 2024-08-11
+updatedAt: 2025-06-29
+title: Documentation du Hook useLocale | react-intlayer
+description: Découvrez comment utiliser le hook useLocale pour le package react-intlayer
+keywords:
+  - useLocale
+  - dictionnaire
+  - clé
+  - Intlayer
+  - Internationalisation
+  - Documentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - react-intlayer
+  - useLocale
+---
+
+# Intégration React : Documentation du Hook `useLocale`
+
+Cette section fournit des détails complets sur le hook `useLocale` de la bibliothèque `react-intlayer`, conçu pour gérer la gestion des locales dans les applications React.
+
+## Importer `useLocale` dans React
+
+Pour intégrer le hook `useLocale` dans votre application React, importez-le depuis son package respectif :
+
+```typescript codeFormat="typescript"
+import { useLocale } from "react-intlayer"; // Utilisé dans les composants React pour la gestion des locales
+```
+
+```javascript codeFormat="esm"
+import { useLocale } from "react-intlayer"; // Utilisé dans les composants React pour la gestion des locales
+```
+
+```javascript codeFormat="commonjs"
+const { useLocale } = require("react-intlayer"); // Utilisé dans les composants React pour la gestion des locales
+```
+
+## Vue d'ensemble
+
+Le hook `useLocale` offre un moyen simple d'accéder et de manipuler les paramètres de locale au sein des composants React. Il permet d'accéder à la locale courante, à la locale par défaut, à toutes les locales disponibles, ainsi qu'aux fonctions pour mettre à jour les paramètres de locale.
+
+## Utilisation
+
+Voici comment vous pouvez utiliser le hook `useLocale` dans un composant React :
+
+```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>Locale actuelle : {locale}</h1>
+      <p>Locale par défaut : {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>Locale actuelle : {locale}</h1>
+      <p>Locale par défaut : {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>Locale actuelle : {locale}</h1>
+      <p>Locale par défaut : {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;
+```
+
+## Paramètres et valeurs de retour
+
+Lorsque vous invoquez le hook `useLocale`, il retourne un objet contenant les propriétés suivantes :
+
+- **`locale`** : La locale actuelle telle que définie dans le contexte React.
+- **`defaultLocale`** : La locale principale définie dans la configuration.
+- **`availableLocales`** : Une liste de toutes les locales disponibles telles que définies dans la configuration.
+- **`setLocale`** : Une fonction pour mettre à jour la locale actuelle dans le contexte de l'application.
+
+## Exemple
+
+Cet exemple montre un composant qui utilise le hook `useLocale` pour afficher un sélecteur de locale, permettant aux utilisateurs de changer dynamiquement la locale de l'application :
+
+```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>
+  );
+};
+```
+
+## Conclusion
+
+Le hook `useLocale` de `react-intlayer` est un outil essentiel pour gérer les locales dans vos applications React, fournissant la fonctionnalité nécessaire pour adapter efficacement votre application à divers publics internationaux.
+
+## Historique de la documentation
+
+- 5.5.10 - 2025-06-29 : Historique initial

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

@@ -0,0 +1,83 @@
+---
+createdAt: 2025-03-13
+updatedAt: 2025-06-29
+title: Documentation du package | react-native-intlayer
+description: Découvrez comment utiliser le package react-native-intlayer
+keywords:
+  - Intlayer
+  - React Native
+  - react-native-intlayer
+  - Internationalisation
+  - Documentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - react-native-intlayer
+---
+
+# react-native-intlayer : Internationaliser (i18n) une application React Native
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Il est compatible avec des frameworks comme React, React, et Express.js.
+
+**Le package `react-native-intlayer`** vous permet d’internationaliser votre application Vite. Il inclut le plugin Metro pour configurer via des variables d’environnement le [bundler Metro](https://docs.expo.dev/guides/customizing-metro/).
+
+## Pourquoi internationaliser votre application React Native ?
+
+Internationaliser votre application React Native est essentiel pour servir efficacement un public mondial. Cela permet à votre application de fournir du contenu et des messages dans la langue préférée de chaque utilisateur. Cette capacité améliore l’expérience utilisateur et élargit la portée de votre application en la rendant plus accessible et pertinente pour des personnes issues de différents horizons linguistiques.
+
+## Configuration
+
+Le package `react-native-intlayer` fonctionne parfaitement avec le [`package react-intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/index.md), et le [`package intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/index.md). Consultez la documentation correspondante pour plus d’informations.
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de paquets préféré :
+
+```bash packageManager="npm"
+npm install react-native-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add react-native-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add react-native-intlayer
+```
+
+## Exemple d’utilisation
+
+Voici un exemple de comment inclure les plugins dans votre configuration vite.
+
+```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);
+})();
+```
+
+## Maîtriser l’internationalisation de votre application Vite
+
+Intlayer offre de nombreuses fonctionnalités pour vous aider à internationaliser votre application Vite.
+
+**Pour en savoir plus sur ces fonctionnalités, consultez le guide [Internationalisation React (i18n) avec Intlayer et React Native](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_with_react_native+expo.md) pour les applications React Native.**
+
+## En savoir plus sur Intlayer
+
+- [Site web d’Intlayer](https://intlayer.org)
+- [Documentation Intlayer](https://intlayer.org/doc)
+- [Intlayer GitHub](https://github.com/aymericzip/intlayer)
+
+- [Posez vos questions à notre documentation intelligente](https://intlayer.org/docchat)
+
+## Historique de la documentation
+
+- 5.5.10 - 2025-06-29 : Historique initial

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

@@ -0,0 +1,80 @@
+---
+createdAt: 2024-08-11
+updatedAt: 2025-06-29
+title: Documentation du package | react-scripts-intlayer
+description: Voir comment utiliser le package react-scripts-intlayer
+keywords:
+  - Intlayer
+  - react-scripts-intlayer
+  - Internationalisation
+  - Documentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - react-scripts-intlayer
+---
+
+# react-scripts-intlayer : Package NPM pour utiliser Intlayer dans une application React Create App
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Il est compatible avec des frameworks comme React, React, et Express.js.
+
+**Le package `react-scripts-intlayer`** inclut les commandes et plugins `react-scripts-intlayer` pour intégrer Intlayer dans une application basée sur Create React App. Ces plugins sont basés sur [craco](https://craco.js.org/) et incluent une configuration supplémentaire pour le bundler [Webpack](https://webpack.js.org/).
+
+## Configuration
+
+Le package `react-scripts-intlayer` fonctionne parfaitement avec le [`package react-intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/index.md) et le [`package intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/index.md). Consultez la documentation correspondante pour plus d'informations.
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de paquets préféré :
+
+```bash packageManager="npm"
+npm install react-scripts-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add react-scripts-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add react-scripts-intlayer
+```
+
+## Utilisation
+
+### Commandes CLI
+
+Le package `react-scripts-intlayer` fournit les commandes CLI suivantes :
+
+- `npx react-scripts-intlayer build` : Compile l'application React avec la configuration Intlayer.
+- `npx react-scripts-intlayer start` : Démarre le serveur de développement avec la configuration Intlayer.
+
+### Remplacer les scripts dans package.json
+
+Pour utiliser le package `react-scripts-intlayer`, vous devez remplacer les scripts dans `package.json` par les commandes suivantes :
+
+```json fileName="package.json"
+{
+  "scripts": {
+    "start": "react-scripts-intlayer start",
+    "build": "react-scripts-intlayer build"
+  }
+}
+```
+
+## Utiliser une configuration Webpack personnalisée
+
+`react-scripts-intlayer` est basé sur [craco](https://craco.js.org/), qui vous permet de personnaliser la configuration Webpack.
+Si vous avez besoin de personnaliser la configuration Webpack, vous pouvez également mettre en place votre propre configuration basée sur le plugin craco d'intlayer. [Voir un exemple ici](https://github.com/aymericzip/intlayer/blob/main/examples/react-app/craco.config.js).
+
+## Lire le guide complet d'Intlayer pour React Create App
+
+Intlayer offre de nombreuses fonctionnalités pour vous aider à internationaliser votre application React.
+[Voir comment utiliser intlayer avec React Create App](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_with_create_react_app.md).
+
+## Historique de la documentation
+
+- 5.5.10 - 2025-06-29 : Historique initial

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

@@ -0,0 +1,54 @@
+---
+createdAt: 2024-08-11
+updatedAt: 2025-06-29
+title: Documentation du package | solid-intlayer
+description: Découvrez comment utiliser le package solid-intlayer
+keywords:
+  - Intlayer
+  - solid-intlayer
+  - Internationalisation
+  - Documentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - solid-intlayer
+---
+
+# solid-intlayer : Package NPM pour internationaliser (i18n) une application Solid
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Il est compatible avec des frameworks comme Solid, Solid, et Express.js.
+
+**Le package `solid-intlayer`** vous permet d'internationaliser votre application Solid. Il fournit des fournisseurs de contexte et des hooks pour l'internationalisation dans Solid.
+
+## Pourquoi internationaliser votre application Solid ?
+
+Internationaliser votre application Solid est essentiel pour servir efficacement un public mondial. Cela permet à votre application de délivrer du contenu et des messages dans la langue préférée de chaque utilisateur. Cette capacité améliore l'expérience utilisateur et élargit la portée de votre application en la rendant plus accessible et pertinente pour des personnes issues de différents horizons linguistiques.
+
+## Pourquoi intégrer Intlayer ?
+
+- **Gestion de contenu propulsée par JavaScript** : Exploitez la flexibilité de JavaScript pour définir et gérer votre contenu de manière efficace.
+- **Environnement à typage sûr** : Profitez de TypeScript pour garantir que toutes vos définitions de contenu soient précises et sans erreur.
+- **Fichiers de contenu intégrés** : Gardez vos traductions proches de leurs composants respectifs, améliorant ainsi la maintenabilité et la clarté.
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de paquets préféré :
+
+```bash packageManager="npm"
+npm install solid-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add solid-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add solid-intlayer
+```
+
+## Historique de la documentation
+
+- 5.5.10 - 2025-06-29 : Historique initial