@intlayer/docs 9.0.0-canary.3 → 9.0.0-canary.5

package/docs/fr/packages/next-intlayer/usePathname.md

@@ -0,0 +1,136 @@
+---
+createdAt: 2026-06-22
+updatedAt: 2026-06-22
+title: Documentation du Hook usePathname | next-intlayer
+description: Découvrez comment utiliser le hook usePathname avec le package next-intlayer
+keywords:
+  - usePathname
+  - pathname
+  - locale
+  - Intlayer
+  - Internationalisation
+  - Documentation
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - packages
+  - next-intlayer
+  - usePathname
+history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Ajout de l'utilitaire usePathname"
+  - version: 8.2.0
+    date: 2026-06-22
+    changes: "Initialisation de l'historique"
+author: aymericzip
+---
+
+# Intégration Next.js : Documentation du Hook `usePathname`
+
+Le hook `usePathname` retourne le chemin (pathname) actuel de Next.js en supprimant le segment de la locale. Il est utile pour créer une navigation adaptée à la locale — par exemple, déterminer quel élément de navigation est actif — sans avoir à retirer manuellement le préfixe de la locale.
+
+## Importer `usePathname` dans Next.js
+
+```typescript
+import { usePathname } from "next-intlayer";
+```
+
+## Aperçu
+
+`usePathname` enveloppe le hook natif `usePathname()` de Next.js provenant de `next/navigation`, ajoute les paramètres de recherche (search params), et retire le préfixe de la locale via `getPathWithoutLocale`. Il se met à jour à chaque navigation côté client. Ce hook n'est disponible que dans les Composants Clients (Client Components, nécessite `"use client"`).
+
+## Utilisation
+
+```tsx fileName="src/components/NavItem.tsx" codeFormat={["typescript", "esm"]}
+"use client";
+
+import type { FC } from "react";
+import { usePathname } from "next-intlayer";
+
+type NavItemProps = {
+  href: string;
+  label: string;
+};
+
+const NavItem: FC<NavItemProps> = ({ href, label }) => {
+  const pathname = usePathname();
+  const isActive = pathname === href;
+
+  return (
+    <a href={href} aria-current={isActive ? "page" : undefined}>
+      {label}
+    </a>
+  );
+};
+
+export default NavItem;
+```
+
+## Valeur de retour
+
+| Type     | Description                                                                                         |
+| -------- | --------------------------------------------------------------------------------------------------- |
+| `string` | Le chemin actuel sans le préfixe de locale et les paramètres de recherche débarrassés de la locale. |
+
+## Comportement
+
+- **Suppression de la locale** : Retire le segment de locale initial (ex. `/fr/dashboard` → `/dashboard`).
+- **Suppression des paramètres de recherche** : Retire également le paramètre de requête `?locale=...` lorsqu'un mode de routage basé sur les paramètres de recherche est utilisé.
+- **Réactif** : Se met à jour à chaque navigation côté client via Next.js App Router.
+- **Compatible SSR** : Retourne le chemin côté serveur lors du premier rendu, puis synchronise les paramètres de recherche côté client.
+
+## Comparaison avec `useLocale`
+
+`useLocale` de `next-intlayer` expose déjà `pathWithoutLocale` dans sa valeur de retour. Utilisez `usePathname` lorsque vous n'avez besoin que du chemin et non de la fonctionnalité de changement de locale.
+
+```tsx codeFormat={["typescript", "esm"]}
+// Lorsque vous avez besoin à la fois de l'état de la locale et du chemin :
+import { useLocale } from "next-intlayer";
+const { locale, pathWithoutLocale } = useLocale();
+
+// Lorsque vous n'avez besoin que du chemin :
+import { usePathname } from "next-intlayer";
+const pathname = usePathname();
+```
+
+## Exemple
+
+```tsx fileName="src/components/Sidebar.tsx" codeFormat={["typescript", "esm"]}
+"use client";
+
+import type { FC } from "react";
+import { usePathname } from "next-intlayer";
+
+const links = [
+  { href: "/dashboard", label: "Tableau de bord" },
+  { href: "/settings", label: "Paramètres" },
+];
+
+const Sidebar: FC = () => {
+  const pathname = usePathname();
+
+  return (
+    <nav>
+      {links.map(({ href, label }) => (
+        <a
+          key={href}
+          href={href}
+          style={{ fontWeight: pathname === href ? "bold" : "normal" }}
+        >
+          {label}
+        </a>
+      ))}
+    </nav>
+  );
+};
+
+export default Sidebar;
+```
+
+## Liens connexes
+
+- [`useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/next-intlayer/useLocale.md) — locale actuelle + sélecteur de locale (expose aussi `pathWithoutLocale`)
+- [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getPathWithoutLocale.md) — l'utilitaire sous-jacent utilisé par ce hook

package/docs/fr/packages/next-intlayer/useRewriteURL.md

@@ -23,14 +23,6 @@ Le hook `useRewriteURL` pour Next.js est un hook côté client qui gère automat
 
 Ce hook fonctionne discrètement en utilisant `window.history.replaceState`, évitant des navigations redondantes via le routeur Next.js ou des rafraîchissements de page.
 
-## Comment ça fonctionne
-
-1. **Surveillance du chemin** : Le hook écoute les changements de la `locale` de l'utilisateur.
-2. **Détection de réécriture** : Il compare le `window.location.pathname` actuel aux règles de réécriture dans votre configuration.
-3. **Correction de l'URL** : Si un alias localisé plus lisible est trouvé pour le chemin courant, le hook déclenche un `window.history.replaceState` pour mettre à jour la barre d'adresse tout en maintenant l'utilisateur sur la même page interne.
-
-## Pourquoi l'utiliser dans Next.js ?
-
 ## Utilisation
 
 Appelez simplement le hook dans un Client Component qui fait partie de votre layout.

package/docs/fr/packages/preact-intlayer/exports.md

@@ -14,6 +14,9 @@ slugs:
   - preact-intlayer
   - exports
 history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Ajout de l'utilitaire usePathname"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Documentation unifiée pour tous les exports"
@@ -40,12 +43,13 @@ npm install preact-intlayer
 
 ### Hooks
 
-| Hook            | Description                                                                                                                   | Doc associée                                                                                          |
-| --------------- | ----------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
-| `useIntlayer`   | Basé sur `useDictionary`, mais injecte une version optimisée du dictionnaire issue de la déclaration générée.                 | -                                                                                                     |
-| `useDictionary` | Traite les objets qui ressemblent à des dictionnaires (clé, contenu). Il traite les traductions `t()`, les énumérations, etc. | -                                                                                                     |
-| `useLocale`     | Renvoie la locale actuelle et une fonction pour la définir.                                                                   | -                                                                                                     |
-| `t`             | Sélectionne le contenu en fonction de la locale courante.                                                                     | [traduction](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/translation.md) |
+| Hook            | Description                                                                                                                   | Doc associée                                                                                                         |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `useIntlayer`   | Basé sur `useDictionary`, mais injecte une version optimisée du dictionnaire issue de la déclaration générée.                 | -                                                                                                                    |
+| `useDictionary` | Traite les objets qui ressemblent à des dictionnaires (clé, contenu). Il traite les traductions `t()`, les énumérations, etc. | -                                                                                                                    |
+| `useLocale`     | Renvoie la locale actuelle et une fonction pour la définir.                                                                   | -                                                                                                                    |
+| `usePathname`   | Hook qui retourne le chemin actuel avec le segment de locale retiré. Réactif à la navigation du navigateur via `popstate`.    | [usePathname](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/preact-intlayer/usePathname.md) |
+| `t`             | Sélectionne le contenu en fonction de la locale courante.                                                                     | [traduction](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/translation.md)                |
 
 ### Composants
 

package/docs/fr/packages/preact-intlayer/usePathname.md

@@ -0,0 +1,117 @@
+---
+createdAt: 2026-06-22
+updatedAt: 2026-06-22
+title: Documentation du Hook usePathname | preact-intlayer
+description: Découvrez comment utiliser le hook usePathname avec le package preact-intlayer
+keywords:
+  - usePathname
+  - pathname
+  - locale
+  - Intlayer
+  - Internationalisation
+  - Documentation
+  - Preact
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - preact-intlayer
+  - usePathname
+history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Ajout de l'utilitaire usePathname"
+  - version: 8.2.0
+    date: 2026-06-22
+    changes: "Initialisation de l'historique"
+author: aymericzip
+---
+
+# Intégration Preact : Documentation du Hook `usePathname`
+
+Le hook `usePathname` retourne le chemin actuel du navigateur en supprimant le segment de la locale. Il est utile pour créer une navigation adaptée à la locale — par exemple, pour déterminer quel élément de navigation est actif — sans avoir à supprimer manuellement le préfixe de la locale.
+
+## Importer `usePathname` dans Preact
+
+```typescript
+import { usePathname } from "preact-intlayer";
+```
+
+## Aperçu
+
+`usePathname` lit `window.location.pathname`, retire le préfixe de la locale via `getPathWithoutLocale`, et déclenche un nouveau rendu du composant chaque fois que le navigateur émet un événement `popstate` (navigation via les boutons Précédent/Suivant). Il retourne une chaîne vide pendant le rendu côté serveur (SSR).
+
+## Utilisation
+
+```tsx fileName="src/components/NavItem.tsx"
+import type { FunctionComponent } from "preact";
+import { usePathname } from "preact-intlayer";
+
+type NavItemProps = {
+  href: string;
+  label: string;
+};
+
+const NavItem: FunctionComponent<NavItemProps> = ({ href, label }) => {
+  const pathname = usePathname();
+  const isActive = pathname === href;
+
+  return (
+    <a href={href} aria-current={isActive ? "page" : undefined}>
+      {label}
+    </a>
+  );
+};
+
+export default NavItem;
+```
+
+## Valeur de Retour
+
+| Type     | Description                                                                            |
+| -------- | -------------------------------------------------------------------------------------- |
+| `string` | Le chemin actuel sans le préfixe de la locale. Chaîne vide lors du rendu côté serveur. |
+
+## Comportement
+
+- **Suppression de la locale** : Retire le segment de locale au début de l'URL (ex. `/fr/dashboard` → `/dashboard`).
+- **Réactif** : Se met à jour automatiquement lors des événements `popstate` (navigation Précédent / Suivant du navigateur).
+- **Compatible SSR** : Retourne `""` lorsque `window` n'est pas disponible.
+- **Nettoyage** : L'écouteur `popstate` est supprimé automatiquement lors du démontage du composant.
+
+## Exemple
+
+```tsx fileName="src/components/Sidebar.tsx"
+import type { FunctionComponent } from "preact";
+import { usePathname } from "preact-intlayer";
+
+const links = [
+  { href: "/dashboard", label: "Tableau de bord" },
+  { href: "/settings", label: "Paramètres" },
+];
+
+const Sidebar: FunctionComponent = () => {
+  const pathname = usePathname();
+
+  return (
+    <nav>
+      {links.map(({ href, label }) => (
+        <a
+          key={href}
+          href={href}
+          style={{ fontWeight: pathname === href ? "bold" : "normal" }}
+        >
+          {label}
+        </a>
+      ))}
+    </nav>
+  );
+};
+
+export default Sidebar;
+```
+
+## Ressources associées
+
+- [`useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/preact-intlayer/exports.md) — locale actuelle + sélecteur de locale
+- [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getPathWithoutLocale.md) — l'utilitaire sous-jacent employé par ce hook

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

@@ -14,6 +14,9 @@ slugs:
   - react-intlayer
   - exports
 history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Ajout de l'utilitaire usePathname"
   - version: 7.5.14
     date: 2026-01-21
     changes: "Documentation unifiée pour tous les exports"
@@ -64,6 +67,7 @@ import "react-intlayer";
 | `useDictionaryDynamic` | Hook qui gère des dictionnaires dynamiques chargés par clé. Utilise React Suspense en interne pour gérer les états de chargement.                     | -                                                                                                                       |
 | `useLocale`            | Hook côté client pour obtenir la locale courante, la locale par défaut, les locales disponibles, et une fonction pour mettre à jour la locale.        | [useLocale](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/useLocale.md)         |
 | `useLocaleBase`        | Hook pour obtenir la locale actuelle et tous les champs associés (locale, defaultLocale, availableLocales, setLocale) depuis le contexte.             | -                                                                                                                       |
+| `usePathname`          | Hook qui renvoie le chemin actuel (pathname) avec le segment de locale supprimé. Réactif à la navigation du navigateur via `popstate`.                | [usePathname](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/usePathname.md)     |
 | `useRewriteURL`        | Hook côté client pour gérer les réécritures d'URL. Si une règle de réécriture existe pour le pathname et la locale actuels, elle mettra à jour l'URL. | [useRewriteURL](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/useRewriteURL.md) |
 | `useI18n`              | Hook qui fournit une fonction de traduction `t()` pour accéder au contenu imbriqué par clé. Imite le pattern i18next/next-intl.                       | [useI18n](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/useI18n.md)             |
 | `useIntl`              | Hook qui fournit un objet `Intl` lié à la locale. Injecte automatiquement la locale courante et utilise un cache optimisé.                            | -                                                                                                                       |

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

@@ -1,176 +1,60 @@
 ---
-createdAt: 2025-02-07
-updatedAt: 2025-06-29
-title: Hook useDictionary - Documentation React Intlayer
-description: Guide complet pour utiliser le hook useDictionary dans les applications React avec Intlayer pour une gestion efficace du contenu localisé sans éditeur visuel.
+createdAt: 2026-01-21
+updatedAt: 2026-01-21
+title: Documentation du Hook useDictionary | react-intlayer
+description: Découvrez comment utiliser le hook useDictionary pour le package react-intlayer
 keywords:
   - useDictionary
-  - React
-  - hook
+  - dictionary
+  - Intlayer
   - intlayer
-  - localisation
-  - i18n
-  - dictionnaire
-  - traduction
+  - Internationalisation
+  - Documentation
 slugs:
   - doc
   - packages
   - react-intlayer
   - useDictionary
 history:
-  - version: 5.5.10
-    date: 2025-06-29
-    changes: "Historique initial"
+  - version: 7.5.14
+    date: 2026-01-21
+    changes: "Documentation unifiée pour tous les exports"
 author: aymericzip
 ---
 
-# Intégration React : Documentation du hook `useDictionary`
+# Documentation du Hook useDictionary
 
-Cette section fournit des instructions détaillées sur l'utilisation du hook `useDictionary` dans les applications React, permettant une gestion efficace du contenu localisé sans éditeur visuel.
+Le hook `useDictionary` vous permet de traiter un objet qui ressemble à un dictionnaire (contenant des clés et du contenu) et de gérer les traductions, énumérations, etc., en son sein. Contrairement à `useIntlayer`, qui est conçu pour fonctionner avec les déclarations de dictionnaire générées, `useDictionary` est plus flexible et peut être utilisé avec n'importe quel objet qui suit la structure d'un dictionnaire.
 
-## Importation de `useDictionary` dans React
+## Utilisation
 
-Le hook `useDictionary` peut être intégré dans les applications React en l'important selon le contexte :
-
-- **Composant Client :**
-
-  ```typescript codeFormat="typescript"
-  import { useDictionary } from "react-intlayer"; // Utilisé dans les composants React côté client
-  ```
-
-  ```javascript codeFormat="esm"
-  import { useDictionary } from "react-intlayer"; // Utilisé dans les composants React côté client
-  ```
-
-  ```javascript codeFormat="commonjs"
-  const { useDictionary } = require("react-intlayer"); // Utilisé dans les composants React côté client
-  ```
-
-- **Composant Serveur :**
-
-  ```typescript codeFormat="typescript"
-  import { useDictionary } from "react-intlayer/server"; // Utilisé dans les composants React côté serveur
-  ```
-
-  ```javascript codeFormat="esm"
-  import { useDictionary } from "react-intlayer/server"; // Utilisé dans les composants React côté serveur
-  ```
-
-  ```javascript codeFormat="commonjs"
-  const { useDictionary } = require("react-intlayer/server"); // Utilisé dans les composants React côté serveur
-  ```
-
-## Paramètres
-
-Le hook accepte deux paramètres :
-
-1. **`dictionary`** : Un objet dictionnaire déclaré contenant le contenu localisé pour des clés spécifiques.
-2. **`locale`** (optionnel) : La locale souhaitée. Par défaut, la locale du contexte actuel est utilisée si elle n'est pas spécifiée.
-
-## Dictionnaire
-
-Tous les objets dictionnaires doivent être déclarés dans des fichiers de contenu structurés afin d'assurer la sécurité des types et d'éviter les erreurs d'exécution. Vous pouvez trouver les [instructions d'installation ici](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/content_file.md). Voici un exemple de déclaration de contenu :
-
-```typescript fileName="./component.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
-import { t, type Dictionary } from "intlayer";
-
-const componentContent = {
-  key: "component-example",
-  content: {
-    title: t({
-      en: "Client Component Example",
-      fr: "Exemple de composant client",
-      es: "Ejemplo de componente cliente",
-    }),
-    content: t({
-      en: "This is the content of a client component example",
-      fr: "Ceci est le contenu d'un exemple de composant client",
-      es: "Este es el contenido de un ejemplo de componente cliente",
-    }),
-  },
-} satisfies Dictionary;
-
-export default componentContent;
-```
-
-```json fileName="./component.content.json" contentDeclarationFormat="json"
-{
-  "$schema": "https://intlayer.org/schema.json",
-  "key": "component-example",
-  "content": {
-    "title": {
-      "nodeType": "translation",
-      "translation": {
-        "en": "Client Component Example",
-        "fr": "Exemple de composant client",
-        "es": "Ejemplo de componente cliente"
-      }
-    },
-    "content": {
-      "nodeType": "translation",
-      "translation": {
-        "en": "This is the content of a client component example",
-        "fr": "Ceci est le contenu d'un exemple de composant client",
-        "es": "Este es el contenido de un ejemplo de componente cliente"
-      }
-    }
-  }
-}
-```
-
-## Exemple d'utilisation dans React
-
-Voici un exemple de la façon d'utiliser le hook `useDictionary` dans un composant React :
-
-```tsx fileName="./ComponentExample.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
+```tsx
 import { useDictionary } from "react-intlayer";
-import componentContent from "./component.content";
-
-const ComponentExample: FC = () => {
-  const { title, content } = useDictionary(componentContent);
-
-  return (
-    <div>
-      <h1>{title}</h1>
-      <p>{content}</p>
-    </div>
-  );
-};
-```
-
-## Intégration Serveur
-
-Si vous utilisez le hook `useDictionary` en dehors du `IntlayerProvider`, la locale doit être explicitement fournie en paramètre lors du rendu du composant :
-
-```tsx fileName="./ServerComponentExample.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { useDictionary } from "react-intlayer/server";
-import clientComponentExampleContent from "./component.content";
-
-const ServerComponentExample: FC<{ locale: string }> = ({ locale }) => {
-  const { content } = useDictionary(clientComponentExampleContent, locale);
+import { t } from "intlayer";
+
+const MyComponent = () => {
+  const content = useDictionary({
+    key: "my_key",
+    content: {
+      myTranslation: t({
+        en: "Hello",
+        fr: "Bonjour",
+      }),
+    },
+  });
 
   return (
     <div>
-      <h1>{content.title}</h1>
-      <p>{content.content}</p>
+      <p>{content.myTranslation}</p>
     </div>
   );
 };
 ```
 
-## Notes sur les attributs
-
-Contrairement aux intégrations utilisant des éditeurs visuels, les attributs comme `buttonTitle.value` ne s'appliquent pas ici. Accédez directement aux chaînes localisées telles que déclarées dans votre contenu.
-
-```jsx
-<button title={content.title}>{content.content}</button>
-```
-
-## Conseils supplémentaires
+## Description
 
-- **Sécurité de type** : Utilisez toujours `Dictionary` pour définir vos dictionnaires afin d'assurer la sécurité de type.
-- **Mises à jour de la localisation** : Lors de la mise à jour du contenu, assurez-vous que toutes les locales sont cohérentes pour éviter les traductions manquantes.
+Le hook effectue les tâches suivantes :
 
-Cette documentation se concentre sur l'intégration du hook `useDictionary`, offrant une approche simplifiée pour gérer le contenu localisé sans dépendre des fonctionnalités des éditeurs visuels.
+1. **Détection de la locale** : Il utilise la locale actuelle du contexte `IntlayerProvider`.
+2. **Traitement de la traduction** : il résout le contenu en fonction de la locale détectée, en traitant toutes les définitions `t()`, `enu()`, etc., trouvées dans l'objet.
+3. **Contenu flexible** : Il fonctionne directement avec l'objet qui lui est passé, ce qui le rend idéal pour du contenu dynamique ou des objets qui ne font pas partie des dictionnaires standard pré-compilés.

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

@@ -29,49 +29,6 @@ author: aymericzip
 
 Cette section fournit des instructions détaillées sur l'utilisation du hook `useIntlayer` dans les applications React, permettant une localisation efficace du contenu.
 
-## Importer `useIntlayer` dans React
-
-Le hook `useIntlayer` peut être intégré dans les applications React en l'important selon le contexte :
-
-- **Composant Client :**
-
-  ```typescript codeFormat="typescript"
-  import { useIntlayer } from "react-intlayer"; // Utilisé dans les composants React côté client
-  ```
-
-  ```javascript codeFormat="esm"
-  import { useIntlayer } from "react-intlayer"; // Utilisé dans les composants React côté client
-  ```
-
-  ```javascript codeFormat="commonjs"
-  const { useIntlayer } = require("react-intlayer"); // Utilisé dans les composants React côté client
-  ```
-
-- **Composant Serveur :**
-
-  ```typescript codeFormat="commonjs"
-  import { useIntlayer } from "react-intlayer/server"; // Utilisé dans les composants React côté serveur
-  ```
-
-  ```javascript codeFormat="esm"
-  import { useIntlayer } from "react.intlayer/server"; // Utilisé dans les composants React côté serveur
-  ```
-
-  ```javascript codeFormat="commonjs"
-  const { useIntlayer } = require("react-intlayer/server"); // Utilisé dans les composants React côté serveur
-  ```
-
-## Paramètres
-
-Le hook accepte deux paramètres :
-
-1. **`key`** : La clé du dictionnaire pour récupérer le contenu localisé.
-2. **`locale`** (optionnel) : La locale souhaitée. Par défaut, la locale du contexte est utilisée si elle n'est pas spécifiée.
-
-## Dictionnaire
-
-Toutes les clés du dictionnaire doivent être déclarées dans des fichiers de déclaration de contenu afin d'améliorer la sécurité des types et d'éviter les erreurs. Vous pouvez trouver les [instructions d'installation ici](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/content_file.md).
-
 ## Exemple d'utilisation dans React
 
 Démonstration du hook `useIntlayer` dans un composant React :
@@ -131,14 +88,6 @@ const ServerComponentExample = () => {
 };
 ```
 
-## Gestion des attributs
-
-Lors de la localisation des attributs, accédez aux valeurs du contenu de manière appropriée :
-
-```jsx
-<button title={content.buttonTitle.value}>{content.buttonText}</button>
-```
-
 ## Ressources supplémentaires
 
 - **Éditeur visuel Intlayer** : Pour une expérience de gestion de contenu plus intuitive, consultez la documentation de l'éditeur visuel [ici](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_visual_editor.md).