@intlayer/docs 5.5.8

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

@@ -0,0 +1,226 @@
+# Intégration React : Documentation du Hook `useIntlayerAsync`
+
+Le hook `useIntlayerAsync` étend la fonctionnalité de `useIntlayer` en retournant non seulement des dictionnaires pré-rendus, mais également en récupérant des 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échargé ou inclus statiquement (comme le ferait `useIntlayer`), puis récupère et fusionne de manière asynchrone tout nouveau dictionnaire distant 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 utilisateur qui permet aux non-développeurs de gérer et de mettre à jour le contenu des applications de manière transparente. En utilisant le tableau de bord intuitif d'Intlayer, votre équipe peut modifier le texte localisé, 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. **Poussez un nouveau dictionnaire de locale 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 la récupération et l'édition asynchrones via la plateforme Intlayer.
+
+## Importation de `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 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 pour le rendu avec la superposition de l'éditeur Intlayer. Si défini sur `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 actuellement 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.
+- Pendant 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 d'attribut localisées pour diverses propriétés 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 d'exécution. Ces fichiers permettent la validation TypeScript, garantissant 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/fr/dictionary/get_started.md).
+
+## Informations supplémentaires
+
+- **Éditeur visuel Intlayer :**  
+  Intégrez-vous à 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/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échargés avec des mises à jour de dictionnaires asynchrones. En utilisant `isLoading` et les 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.

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

@@ -0,0 +1,184 @@
+# 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 paramètres régionaux dans les applications React.
+
+## Importation de `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 paramètres régionaux
+```
+
+```javascript codeFormat="esm"
+import { useLocale } from "react-intlayer"; // Utilisé dans les composants React pour la gestion des paramètres régionaux
+```
+
+```javascript codeFormat="commonjs"
+const { useLocale } = require("react-intlayer"); // Utilisé dans les composants React pour la gestion des paramètres régionaux
+```
+
+## Vue d'ensemble
+
+Le hook `useLocale` offre un moyen simple d'accéder et de manipuler les paramètres régionaux au sein des composants React. Il permet d'accéder à la langue actuelle, à la langue par défaut, à toutes les langues disponibles, ainsi qu'à des fonctions pour mettre à jour les paramètres régionaux.
+
+## Utilisation
+
+Voici comment 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>Langue actuelle : {locale}</h1>
+      <p>Langue 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>Langue actuelle : {locale}</h1>
+      <p>Langue 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>Langue actuelle : {locale}</h1>
+      <p>Langue 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 langue actuelle définie dans le contexte React.
+- **`defaultLocale`** : La langue principale définie dans la configuration.
+- **`availableLocales`** : Une liste de toutes les langues disponibles définies dans la configuration.
+- **`setLocale`** : Une fonction pour mettre à jour la langue actuelle dans le contexte de l'application.
+
+## Exemple
+
+Cet exemple montre un composant qui utilise le hook `useLocale` pour afficher un sélecteur de langue, permettant aux utilisateurs de changer dynamiquement la langue 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 paramètres régionaux dans vos applications React, offrant les fonctionnalités nécessaires pour adapter efficacement votre application à divers publics internationaux.

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

@@ -0,0 +1,57 @@
+**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 `react-native-intlayer`** vous permet d'internationaliser votre application Vite. Il inclut le plugin Metro pour configurer les variables d'environnement dans le [Metro bundler](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 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/fr/packages/react-intlayer/index.md), et le [`package intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/fr/packages/intlayer/index.md). Consultez la documentation pertinente pour plus d'informations.
+
+## Installation
+
+Installez le package nécessaire en utilisant votre gestionnaire de packages 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 pour 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 propose de nombreuses fonctionnalités pour vous aider à internationaliser votre application Vite.
+
+**Pour en savoir plus sur ces fonctionnalités, consultez le guide [Internationalisation (i18n) avec Intlayer et React Native](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_with_react_native+expo.md) pour les applications React Native.**
+
+## En savoir plus sur Intlayer
+
+- [Site Web Intlayer](https://intlayer.org)
+- [Documentation Intlayer](https://intlayer.org/doc)
+- [GitHub Intlayer](https://github.com/aymericzip/intlayer)
+
+- [Posez vos questions à notre documentation intelligente](https://intlayer.org/docchat)

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

@@ -0,0 +1,57 @@
+# 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. Elle 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 avec 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/fr/packages/react-intlayer/index.md), et le [package `intlayer`](https://github.com/aymericzip/intlayer/blob/main/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 packages 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 de package.json
+
+Pour utiliser le package `react-scripts-intlayer`, vous devez remplacer les scripts de `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/), ce qui vous permet de personnaliser la configuration Webpack.
+Si vous avez besoin de personnaliser la configuration Webpack, vous pouvez également implémenter 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/fr/intlayer_with_create_react_app.md).

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

@@ -0,0 +1,3 @@
+this doc will be automatically generated translated from the english doc
+
+see /docs/en/packages/solid-intlayer/index.md

package/fr/packages/svelte-intlayer/index.md

@@ -0,0 +1,3 @@
+this doc will be automatically generated translated from the english doc
+
+see /docs/en/packages/svelte-intlayer/index.md

package/fr/packages/vite-intlayer/index.md

@@ -0,0 +1,53 @@
+# vite-intlayer : Package NPM pour internationaliser (i18n) une application Vite
+
+**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 `vite-intlayer`** vous permet d'internationaliser votre application Vite. Il inclut le plugin Vite pour configurer les variables d'environnement dans le [bundler Vite](https://vitejs.dev/guide/why.html#why-bundle-for-production). Il fournit également un middleware pour détecter la langue préférée de l'utilisateur et le rediriger vers l'URL appropriée, comme spécifié dans la [configuration](https://github.com/aymericzip/intlayer/blob/main/docs/fr/configuration.md).
+
+## Pourquoi internationaliser votre application Vite ?
+
+Internationaliser votre application Vite 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 de différents horizons linguistiques.
+
+## Configuration
+
+Le package `vite-intlayer` fonctionne parfaitement avec le [`react-intlayer` package](https://github.com/aymericzip/intlayer/blob/main/docs/fr/packages/react-intlayer/index.md), et le [`intlayer` package](https://github.com/aymericzip/intlayer/blob/main/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 packages préféré :
+
+```bash packageManager="npm"
+npm install vite-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add vite-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add vite-intlayer
+```
+
+## Exemple d'utilisation
+
+Voici un exemple d'intégration des plugins dans votre configuration Vite.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayerPlugin, intLayerMiddlewarePlugin } from "vite-intlayer";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [intlayerPlugin(), intLayerMiddlewarePlugin()],
+});
+```
+
+> Le plugin Vite `intlayerPlugin()` est utilisé pour intégrer Intlayer avec Vite. Il garantit la création des fichiers de déclaration de contenu et les surveille en mode développement. Il définit les variables d'environnement Intlayer dans l'application Vite. De plus, il fournit des alias pour optimiser les performances.
+
+> Le `intLayerMiddlewarePlugin()` ajoute un routage côté serveur à votre application. Ce plugin détectera automatiquement la langue actuelle en fonction de l'URL et définira le cookie de langue approprié. Si aucune langue n'est spécifiée, le plugin déterminera la langue la plus appropriée en fonction des préférences linguistiques du navigateur de l'utilisateur. Si aucune langue n'est détectée, il redirigera vers la langue par défaut.
+
+## 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 (i18n) avec Intlayer, Vite et React](https://github.com/aymericzip/intlayer/blob/main/docs/fr/intlayer_with_vite+react.md) pour les applications Vite et React.**

package/fr/packages/vue-intlayer/index.md

@@ -0,0 +1,3 @@
+this doc will be automatically generated translated from the english doc
+
+see /docs/en/packages/vue-intlayer/index.md