@intlayer/docs 5.5.8

package/fr/introduction.md

@@ -0,0 +1,190 @@
+# Documentation Intlayer
+
+Bienvenue dans la documentation officielle d'Intlayer ! Ici, vous trouverez tout ce dont vous avez besoin pour intégrer, configurer et maîtriser Intlayer pour tous vos besoins en matière d'internationalisation (i18n), que vous travailliez avec Next.js, React, Vite, Express ou un autre environnement JavaScript.
+
+## Introduction
+
+### Qu'est-ce qu'Intlayer ?
+
+**Intlayer** est une bibliothèque d'internationalisation conçue spécifiquement pour les développeurs JavaScript. Elle permet la déclaration de votre contenu partout dans votre code. Elle convertit la déclaration de contenu multilingue en dictionnaires structurés pour une intégration facile dans votre code. En utilisant TypeScript, **Intlayer** rend votre développement plus robuste et plus efficace.
+
+Intlayer propose également un éditeur visuel optionnel qui vous permet de modifier et de gérer facilement votre contenu. Cet éditeur est particulièrement utile pour les développeurs qui préfèrent une interface visuelle pour la gestion de contenu, ou pour les équipes générant du contenu sans avoir à se soucier du code.
+
+### Exemple d'utilisation
+
+```bash codeFormat="typescript"
+.
+└── Components
+    └── MyComponent
+        ├── index.content.ts
+        └── index.tsx
+```
+
+```bash codeFormat="commonjs"
+.
+└── Components
+    └── MyComponent
+        ├── index.content.cjs
+        └── index.mjs
+```
+
+```bash codeFormat="esm"
+.
+└── Components
+    └── MyComponent
+        ├── index.content.mjs
+        └── index.js
+```
+
+```tsx fileName="src/components/MyComponent/index.content.ts" contentDeclarationFormat="typescript"
+import { t, type Dictionary } from "intlayer";
+
+// Déclaration du contenu du composant
+const componentContent = {
+  key: "component-key",
+  content: {
+    myTranslatedContent: t({
+      en: "Hello World",
+      fr: "Bonjour le monde",
+      es: "Hola Mundo",
+    }),
+  },
+} satisfies Dictionary;
+
+export default componentContent;
+```
+
+```javascript fileName="src/components/MyComponent/index.content.mjs" contentDeclarationFormat="esm"
+import { t } from "intlayer";
+
+/** Déclaration du contenu du composant
+ * @type {import('intlayer').Dictionary} */
+const componentContent = {
+  key: "component-key",
+  content: {
+    myTranslatedContent: t({
+      en: "Hello World",
+      fr: "Bonjour le monde",
+      es: "Hola Mundo",
+    }),
+  },
+};
+
+export default componentContent;
+```
+
+```javascript fileName="src/components/MyComponent/index.content.cjs" contentDeclarationFormat="commonjs"
+const { t } = require("intlayer");
+
+/** Déclaration du contenu du composant
+ * @type {import('intlayer').Dictionary} */
+const componentContent = {
+  key: "component-key",
+  content: {
+    myTranslatedContent: t({
+      en: "Hello World",
+      fr: "Bonjour le monde",
+      es: "Hola Mundo",
+    }),
+  },
+};
+
+module.exports = componentContent;
+```
+
+```json fileName="src/components/MyComponent/index.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "component-key",
+  "content": {
+    "myTranslatedContent": {
+      "nodeType": "translation",
+      "translation": {
+        "en": "Hello World",
+        "fr": "Bonjour le monde",
+        "es": "Hola Mundo"
+      }
+    }
+  }
+}
+```
+
+```tsx fileName="src/components/MyComponent/index.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+// Composant React utilisant Intlayer
+export const MyComponent: FC = () => {
+  const { myTranslatedContent } = useIntlayer("component-key");
+
+  return <span>{myTranslatedContent}</span>;
+};
+```
+
+```jsx fileName="src/components/MyComponent/index.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+// Composant React utilisant Intlayer
+const MyComponent = () => {
+  const { myTranslatedContent } = useIntlayer("component-key");
+
+  return <span>{myTranslatedContent}</span>;
+};
+```
+
+```jsx fileName="src/components/MyComponent/index.csx" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+// Composant React utilisant Intlayer
+const MyComponent = () => {
+  const { myTranslatedContent } = useIntlayer("component-key");
+
+  return <span>{myTranslatedContent}</span>;
+};
+```
+
+## Fonctionnalités principales
+
+Intlayer offre une variété de fonctionnalités adaptées aux besoins du développement web moderne. Voici les principales fonctionnalités, avec des liens vers la documentation détaillée pour chacune :
+
+- **Support de l'internationalisation** : Améliorez la portée globale de votre application avec un support intégré pour l'internationalisation.
+- **Éditeur visuel** : Améliorez votre flux de travail de développement avec des plugins d'éditeur conçus pour Intlayer. Consultez le [Guide de l'Éditeur Visuel](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_visual_editor.md).
+- **Flexibilité de configuration** : Personnalisez votre configuration avec des options détaillées dans le [Guide de Configuration](https://github.com/aymericzip/intlayer/blob/main/docs/fr/configuration.md).
+- **Outils CLI avancés** : Gérez vos projets efficacement grâce à l'interface en ligne de commande d'Intlayer. Explorez les capacités dans la [Documentation des Outils CLI](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_cli.md).
+
+## Concepts de base
+
+### Dictionnaire
+
+Organisez votre contenu multilingue près de votre code pour tout garder cohérent et maintenable.
+
+- **[Commencer](https://github.com/aymericzip/intlayer/blob/main/docs/fr/dictionary/get_started.md)**  
+  Apprenez les bases de la déclaration de contenu dans Intlayer.
+
+- **[Traduction](https://github.com/aymericzip/intlayer/blob/main/docs/fr/dictionary/translation.md)**  
+  Comprenez comment les traductions sont générées, stockées et utilisées dans votre application.
+
+- **[Énumération](https://github.com/aymericzip/intlayer/blob/main/docs/fr/dictionary/enumeration.md)**  
+  Gérez facilement des ensembles de données répétées ou fixes dans différentes langues.
+
+- **[Récupération par fonction](https://github.com/aymericzip/intlayer/blob/main/docs/fr/dictionary/function_fetching.md)**  
+  Découvrez comment récupérer dynamiquement du contenu avec une logique personnalisée pour s'adapter au flux de travail de votre projet.
+
+### Environnements et intégrations
+
+Nous avons conçu Intlayer avec flexibilité à l'esprit, offrant une intégration transparente avec des frameworks et outils de construction populaires :
+
+- **[Intlayer avec Next.js 15](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_with_nextjs_15.md)**
+- **[Intlayer avec Next.js 14 (App Router)](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_with_nextjs_14.md)**
+- **[Intlayer avec Next.js Page Router](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_with_nextjs_page_router.md)**
+- **[Intlayer avec React CRA](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_with_create_react_app.md)**
+- **[Intlayer avec Vite + React](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_with_vite+react.md)**
+- **[Intlayer avec Express](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_with_express.md)**
+
+Chaque guide d'intégration inclut les meilleures pratiques pour utiliser les fonctionnalités d'Intlayer, comme le **rendu côté serveur**, le **routage dynamique** ou le **rendu côté client**, afin que vous puissiez maintenir une application rapide, optimisée pour le SEO et hautement évolutive.
+
+## Contribution et retours
+
+Nous valorisons la puissance de l'open-source et du développement communautaire. Si vous souhaitez proposer des améliorations, ajouter un nouveau guide ou corriger des problèmes dans notre documentation, n'hésitez pas à soumettre une Pull Request ou à ouvrir une issue sur notre [dépôt GitHub](https://github.com/aymericzip/intlayer/blob/main/docs).
+
+**Prêt à traduire votre application plus rapidement et efficacement ?** Plongez dans notre documentation pour commencer à utiliser Intlayer dès aujourd'hui. Découvrez une approche robuste et rationalisée de l'internationalisation qui garde votre contenu organisé et rend votre équipe plus productive.

package/fr/mcp_server.md

@@ -0,0 +1,152 @@
+# Serveur MCP Intlayer
+
+Le **Serveur Intlayer MCP (Model Context Protocol)** offre une assistance IDE alimentée par l'IA, adaptée à l'écosystème Intlayer. Conçu pour les environnements de développement modernes comme **Cursor**, **GitHub Copilot workspace**, et tout IDE prenant en charge le protocole MCP, ce serveur vous fournit une assistance contextuelle et en temps réel basée sur la configuration de votre projet.
+
+## Pourquoi utiliser le Serveur Intlayer MCP ?
+
+En activant le Serveur Intlayer MCP dans votre IDE, vous bénéficiez de :
+
+- **Intégration CLI intelligente**  
+  Accédez et exécutez les commandes CLI d'Intlayer directement depuis l'interface de votre IDE. Consultez la liste complète des commandes et options dans la [documentation CLI d'Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_cli.md).
+
+- **Documentation contextuelle**  
+  Le serveur MCP charge et expose la documentation correspondant à la version d'Intlayer que vous utilisez dans votre projet. Cela garantit que les suggestions de code, les options de commande et les explications sont toujours à jour et pertinentes.
+
+- **Développement assisté par IA**  
+  Avec des suggestions et des autocomplétions adaptées au projet, l'assistant IA peut expliquer votre code, recommander l'utilisation de la CLI ou suggérer comment utiliser des fonctionnalités spécifiques d'Intlayer en fonction de vos fichiers actuels.
+
+- **Configuration légère et instantanée**  
+  Pas de maintenance serveur ou d'installation lourde requise. Configurez simplement votre fichier `.cursor/mcp.json` ou une configuration MCP équivalente et vous êtes prêt à commencer.
+
+---
+
+## Configuration de Cursor
+
+Dans la racine de votre projet, ajoutez le fichier de configuration `.cursor/mcp.json` suivant :
+
+```json
+{
+  "mcpServers": {
+    "intlayer": {
+      "command": "npx",
+      "args": ["-y", "@intlayer/mcp"]
+    }
+  }
+}
+```
+
+Cela indique à votre IDE de lancer le serveur MCP Intlayer en utilisant `npx`, garantissant qu'il utilise toujours la dernière version disponible, sauf si vous la fixez.
+
+---
+
+## Configuration de VS Code
+
+Pour utiliser le Serveur Intlayer MCP avec VS Code, vous devez le configurer dans vos paramètres de workspace ou utilisateur.
+
+### Configuration du Workspace
+
+Créez un fichier `.vscode/mcp.json` dans la racine de votre projet :
+
+```json
+{
+  "servers": {
+    "intlayer": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@intlayer/mcp"]
+    }
+  }
+}
+```
+
+### Utilisation du Serveur MCP dans VS Code
+
+1. **Activer le mode Agent** : Ouvrez la vue Chat (⌃⌘I sur Mac, Ctrl+Alt+I sur Windows/Linux) et sélectionnez le mode **Agent** dans le menu déroulant.
+
+2. **Accéder aux outils** : Cliquez sur le bouton **Tools** pour voir les outils Intlayer disponibles. Vous pouvez sélectionner/désélectionner des outils spécifiques selon vos besoins.
+
+3. **Référence directe aux outils** : Référez-vous directement aux outils dans vos invites en tapant `#` suivi du nom de l'outil.
+
+4. **Confirmation des outils** : Par défaut, VS Code demandera une confirmation avant d'exécuter les outils. Utilisez les options du bouton **Continue** pour confirmer automatiquement les outils pour la session en cours, le workspace ou toutes les futures invocations.
+
+### Gestion du Serveur
+
+- Exécutez **MCP: List Servers** depuis la palette de commandes pour voir les serveurs configurés.
+- Démarrez, arrêtez ou redémarrez le serveur MCP Intlayer selon vos besoins.
+- Consultez les journaux du serveur pour le dépannage en sélectionnant le serveur et en choisissant **Show Output**.
+
+Pour plus d'informations sur l'intégration MCP dans VS Code, consultez la [documentation officielle MCP de VS Code](https://code.visualstudio.com/docs/copilot/chat/mcp-servers).
+
+---
+
+## Utilisation du Serveur MCP via CLI
+
+Vous pouvez également exécuter le serveur MCP Intlayer directement depuis la ligne de commande pour tester, déboguer ou l'intégrer à d'autres outils.
+
+### Installer le Serveur MCP
+
+Tout d'abord, installez le package du serveur MCP globalement ou utilisez-le via npx :
+
+```bash
+# Installer globalement
+npm install -g @intlayer/mcp
+
+# Ou utiliser directement avec npx (recommandé)
+npx @intlayer/mcp
+```
+
+### Démarrer le Serveur
+
+Pour démarrer le serveur MCP avec l'inspecteur pour le débogage et les tests :
+
+```bash
+# Utiliser la commande start intégrée
+npm run start
+
+# Ou directement avec npx
+npx @modelcontextprotocol/inspector npx @intlayer/mcp
+```
+
+Cela lancera le serveur MCP avec une interface d'inspection qui vous permet de :
+
+- Tester les communications du protocole MCP
+- Déboguer les réponses du serveur
+- Valider les implémentations d'outils et de ressources
+- Surveiller les performances du serveur
+
+### Utilisation en Développement
+
+Pour le développement et les tests, vous pouvez exécuter le serveur dans divers modes :
+
+```bash
+# Construire et démarrer en mode développement
+npm run dev
+
+# Exécuter avec une configuration personnalisée
+node dist/cjs/index.cjs
+
+# Tester les fonctionnalités du serveur
+npm test
+```
+
+Le serveur exposera des outils et ressources spécifiques à Intlayer qui peuvent être consommés par tout client compatible MCP, pas seulement Cursor ou d'autres IDE.
+
+---
+
+## Aperçu des fonctionnalités
+
+| Fonctionnalité    | Description                                                                                               |
+| ----------------- | --------------------------------------------------------------------------------------------------------- |
+| Support CLI       | Exécutez les commandes `intlayer`, obtenez des indices d'utilisation et des arguments en ligne            |
+| Docs versionnées  | Détection automatique et chargement de la documentation correspondant à votre version actuelle d'Intlayer |
+| Autocomplétion    | Suggestions intelligentes de commandes et de configurations au fur et à mesure que vous tapez             |
+| Prêt pour plugins | Compatible avec les IDE et outils prenant en charge la norme MCP                                          |
+
+---
+
+## Liens utiles
+
+- [Documentation CLI d'Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_cli.md)
+- [Dépôt GitHub Intlayer](https://github.com/aymericzip/intlayer)
+
+---

package/fr/packages/@intlayer/api/index.md

@@ -0,0 +1,31 @@
+# @intlayer/api : Package NPM pour interagir avec l'API Intlayer
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Elle est compatible avec des frameworks comme React, React et Express.js.
+
+Le package **`@intlayer/api`** est un SDK (Software Development Kit) pour interagir avec l'API Intlayer. Il fournit un ensemble de fonctions pour auditer les déclarations de contenu, interagir avec les organisations, les projets, les utilisateurs, etc.
+
+## Utilisation
+
+```ts
+import { intlayerAPI } from "@intlayer/api";
+
+intlayerAPI.user.getUser({
+  ids: ["user-id-1", "user-id-2"],
+});
+```
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de packages préféré :
+
+```bash packageManager="npm"
+npm install @intlayer/api
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/api
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/api
+```

package/fr/packages/@intlayer/chokidar/index.md

@@ -0,0 +1,31 @@
+# @intlayer/chokidar : Package NPM pour scanner et construire des fichiers de déclaration Intlayer en dictionnaires
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Elle est compatible avec des frameworks comme React, React et Express.js.
+
+Le package **`@intlayer/chokidar`** est utilisé pour scanner et construire des fichiers de déclaration Intlayer en dictionnaires en utilisant [chokidar](https://github.com/paulmillr/chokidar) et selon la [configuration Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/fr/configuration.md).
+
+## Utilisation
+
+```ts
+import { watch, prepareIntlayer } from "@intlayer/chokidar";
+
+await prepareIntlayer(); // Construire les dictionnaires Intlayer
+
+watch({ persistent: true }); // Surveiller les changements dans les fichiers de configuration
+```
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de packages préféré :
+
+```bash packageManager="npm"
+npm install @intlayer/chokidar
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/chokidar
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/chokidar
+```

package/fr/packages/@intlayer/cli/index.md

@@ -0,0 +1,21 @@
+# @intlayer/cli : Package NPM pour utiliser les scripts fournis par l'intlayer CLI
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Elle est compatible avec des frameworks comme React, React et Express.js.
+
+Le package **`@intlayer/cli`** est un package NPM utilisé pour déclarer les scripts liés aux interfaces en ligne de commande d'intlayer. Il garantit l'uniformité de toutes les commandes CLI d'intlayer. Ce package est notamment utilisé par les packages [intlayer-cli](https://github.com/aymericzip/intlayer/tree/main/docs/fr/packages/intlayer-cli/index.md) et [intlayer](https://github.com/aymericzip/intlayer/tree/main/docs/fr/packages/intlayer/index.md).
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de packages préféré :
+
+```bash packageManager="npm"
+npm install @intlayer/cli
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/cli
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/cli
+```

package/fr/packages/@intlayer/config/index.md

@@ -0,0 +1,116 @@
+# @intlayer/config: Paquet NPM pour récupérer la configuration d'Intlayer
+
+**Intlayer** est une suite de paquets conçue spécifiquement pour les développeurs JavaScript. Elle est compatible avec des frameworks comme React, React et Express.js.
+
+Le paquet **`@intlayer/config`** est un paquet NPM qui vous permet de récupérer la configuration d'Intlayer et de définir les variables d'environnement liées à l'environnement actuel.
+
+## Installation
+
+Installez le paquet nécessaire en utilisant votre gestionnaire de paquets préféré :
+
+```bash packageManager="npm"
+npm install @intlayer/config
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/config
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/config
+```
+
+## Utilisation
+
+### Lire la configuration d'Intlayer en utilisant le système de fichiers
+
+Exemple :
+
+```ts
+import { getConfiguration, type IntlayerConfig } from "@intlayer/config";
+
+const config: IntlayerConfig = getConfiguration();
+
+console.log(config);
+// Sortie :
+// {
+//   internationalization: { ... },
+//   middleware: { ... },
+//   content: { ... },
+//   editor: { ... }
+// }
+```
+
+> Cette fonction utilise les paquets `fs` et ne fonctionnera que côté serveur.
+
+### Lire la configuration d'Intlayer en utilisant les variables d'environnement
+
+Exemple :
+
+```ts
+import { getConfiguration, type IntlayerConfig } from "@intlayer/config/client";
+
+const config: IntlayerConfig = getConfiguration({
+  env: "production",
+});
+
+console.log(config);
+// Sortie :
+// {
+//   internationalization: { ... },
+//   middleware: { ... },
+//   content: { ... },
+//   editor: { ... }
+// }
+```
+
+> Cette fonction ne retournera rien si les variables d'environnement ne sont pas définies.
+
+### Définir les variables d'environnement
+
+1. Créez un fichier de configuration.
+
+```ts fileName="intlayer.config.ts"
+import { type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    /* ... */
+  },
+  middleware: {
+    /* ... */
+  },
+  content: {
+    /* ... */
+  },
+  editor: {
+    /* ... */
+  },
+};
+
+export default config;
+```
+
+> Voir [Documentation de configuration d'Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/fr/configuration.md) pour plus de détails.
+
+2. Définissez les variables d'environnement.
+
+```ts
+import { getConfiguration } from "@intlayer/config";
+
+const intlayerConfig = getConfiguration();
+
+// Formater toutes les valeurs de configuration en tant que variables d'environnement
+const env = formatEnvVariable();
+
+// Définir chaque variable d'environnement formatée dans process.env
+Object.assign(process.env, env);
+```
+
+3. Importez le fichier de configuration.
+
+```ts
+import { getConfiguration } from "@intlayer/config/client";
+
+const intlayerConfig = getConfiguration();
+```

package/fr/packages/@intlayer/core/index.md

@@ -0,0 +1,25 @@
+# @intlayer/core : Paquet NPM contenant les fonctions principales d'Intlayer
+
+**Intlayer** est une suite de paquets conçue spécifiquement pour les développeurs JavaScript. Elle est compatible avec des frameworks comme React, React et Express.js.
+
+Le paquet **`@intlayer/core`** est un paquet NPM incluant les fonctions principales d'Intlayer partagées par plusieurs paquets. Il inclut notamment :
+
+- Fonctions de traduction
+- Fonctions de dictionnaire
+- Fonctions utilitaires
+
+## Installation
+
+Installez le paquet nécessaire en utilisant votre gestionnaire de paquets préféré :
+
+```bash packageManager="npm"
+npm install @intlayer/core
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/core
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/core
+```

package/fr/packages/@intlayer/design-system/index.md

@@ -0,0 +1,21 @@
+# @intlayer/design-system: Package NPM contenant la bibliothèque UI d'Intlayer
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Elle est compatible avec des frameworks comme React, React et Express.js.
+
+Le package **`@intlayer/design-system`** est un package NPM incluant le système de design d'Intlayer. Ce package est notamment utilisé par l'[éditeur Intlayer](https://github.com/aymericzip/intlayer/tree/main/docs/fr/packages/intlayer-editor/index.md), dans le [Site Web](https://intlayer.org) et l'[Éditeur Visuel / CMS](https://intlayer.org/dashboard).
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de packages préféré :
+
+```bash packageManager="npm"
+npm install @intlayer/design-system
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/design-system
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/design-system
+```

package/fr/packages/@intlayer/dictionary-entry/index.md

@@ -0,0 +1,21 @@
+# @intlayer/dictionary-entry : Package NPM pour récupérer les dictionnaires Intlayer
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Elle est compatible avec des frameworks comme React, React et Express.js.
+
+Le package **`@intlayer/dictionary-entry`** est un package NPM qui retourne uniquement le chemin d'entrée des dictionnaires intlayer. Étant donné que la recherche dans le système de fichiers est impossible depuis le navigateur, l'utilisation de bundlers comme Webpack ou Rollup pour récupérer le chemin d'entrée des dictionnaires n'est pas possible. Ce package vise à être utilisé comme alias.
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de packages préféré :
+
+```bash packageManager="npm"
+npm install @intlayer/dictionary-entry
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/dictionary-entry
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/dictionary-entry
+```

package/fr/packages/@intlayer/editor/index.md

@@ -0,0 +1,21 @@
+# @intlayer/editor : Package NPM fournissant des utilitaires pour interfacer l'application avec l'éditeur Intlayer et manipuler les dictionnaires
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Elle est compatible avec des frameworks tels que React, Next.js et Express.js.
+
+Le package **`intlayer-editor`** fournit des utilitaires pour interfacer l'application avec l'éditeur Intlayer. Il inclut l'API pour interagir avec l'éditeur, ainsi que des utilitaires pour manipuler les dictionnaires. Ce package est multiplateforme.
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de packages préféré :
+
+```bash
+npm install @intlayer/editor
+```
+
+```bash
+yarn add @intlayer/editor
+```
+
+```bash
+pnpm add @intlayer/editor
+```

package/fr/packages/@intlayer/editor-react/index.md

@@ -0,0 +1,21 @@
+# @intlayer/editor-react : Package NPM fournissant des États React, Contextes, Hooks et Composants pour interagir avec l'éditeur Intlayer
+
+**Intlayer** est une suite de packages conçue spécifiquement pour les développeurs JavaScript. Elle est compatible avec des frameworks comme React, Next.js et Express.js.
+
+Le package **`@intlayer/editor-react`** fournit des états, contextes, hooks et composants pour interagir avec l'éditeur Intlayer dans une application React.
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de packages préféré :
+
+```bash
+npm install @intlayer/editor-react
+```
+
+```bash
+yarn add @intlayer/editor-react
+```
+
+```bash
+pnpm add @intlayer/editor-react
+```