copy(l10n): rules of hooks

Author: tdd

src/content/reference/rules/rules-of-hooks.md

@@ -2,62 +2,62 @@
 title: Les règles des Hooks
 ---
 
-{/* FIXME:L10N */}
-
 <Intro>
-Hooks are defined using JavaScript functions, but they represent a special type of reusable UI logic with restrictions on where they can be called.
+
+Les Hooks sont définis au moyen de fonctions JavaScript, mais représentent un type particulier de logique d'UI réutilisables, avec des restrictions sur leurs emplacements possibles d'appel.
+
 </Intro>
 
 <InlineToc />
 
 ---
 
-##  Only call Hooks at the top level {/*only-call-hooks-at-the-top-level*/}
+## N'appelez des Hooks qu'au niveau racine {/*only-call-hooks-at-the-top-level*/}
 
-Functions whose names start with `use` are called [*Hooks*](/reference/react) in React.
+Les fonctions dont le nom commence par `use` sont appelées [*Hooks*](/reference/react) en React.
 
-**Don’t call Hooks inside loops, conditions, nested functions, or `try`/`catch`/`finally` blocks.** Instead, always use Hooks at the top level of your React function, before any early returns. You can only call Hooks while React is rendering a function component:
+**N'appelez pas de Hooks au sein de boucles, conditions, fonctions imbriquées ou blocks `try`/`catch`/`finally` .** Utilisez plutôt les Hooks systématiquement au niveau racine de votre fonction React, avant tout retour anticipé éventuel *(early return, NdT)*. Vous ne pouvez appelez des Hooks que pendant que React fait le rendu d'une fonction composant :
 
-* ✅ Call them at the top level in the body of a [function component](/learn/your-first-component).
-* ✅ Call them at the top level in the body of a [custom Hook](/learn/reusing-logic-with-custom-hooks).
+* ✅ Appelez-les à la racine du corps d'une [fonction composant](/learn/your-first-component).
+* ✅ Appelez-les à la racine du corps d'un [Hook personnalisé](/learn/reusing-logic-with-custom-hooks).
 
 ```js{2-3,8-9}
 function Counter() {
-  // ✅ Good: top-level in a function component
+  // ✅ Correct : niveau racine d’une fonction composant
   const [count, setCount] = useState(0);
   // ...
 }
 
 function useWindowWidth() {
-  // ✅ Good: top-level in a custom Hook
+  // ✅ Correct : niveau racine d’un Hook personnalisé
   const [width, setWidth] = useState(window.innerWidth);
   // ...
 }
 ```
 
-It’s **not** supported to call Hooks (functions starting with `use`) in any other cases, for example:
+React **ne permet pas** l'appels de Hooks (les fonctions dont le nom commence par `use`) dans d'autres situations, par exemple :
 
-* 🔴 Do not call Hooks inside conditions or loops.
-* 🔴 Do not call Hooks after a conditional `return` statement.
-* 🔴 Do not call Hooks in event handlers.
-* 🔴 Do not call Hooks in class components.
-* 🔴 Do not call Hooks inside functions passed to `useMemo`, `useReducer`, or `useEffect`.
-* 🔴 Do not call Hooks inside `try`/`catch`/`finally` blocks.
+* 🔴 N'appelez pas de Hooks au sein de conditions ou de boucles.
+* 🔴 N'appelez pas de Hooks après une instruction `return` conditionnelle.
+* 🔴 N'appelez pas de Hooks au sein de gestionnaires d'événements.
+* 🔴 N'appelez pas de Hooks dans des composants à base de classes.
+* 🔴 N'appelez pas de Hooks au sein de fonctions passées à `useMemo`, `useReducer` ou `useEffect`.
+* 🔴 N'appelez pas de Hooks au sein de blocs `try`/`catch`/`finally`.
 
-If you break these rules, you might see this error.
+Si vous enfreignez ces règles, vous verrez peut-être une erreur.
 
 ```js{3-4,11-12,20-21}
 function Bad({ cond }) {
   if (cond) {
-    // 🔴 Bad: inside a condition (to fix, move it outside!)
+    // 🔴 Incorrect : au sein d’une condition (pour corriger ça, sortez-en-le !)
     const theme = useContext(ThemeContext);
   }
   // ...
 }
 
 function Bad() {
   for (let i = 0; i < 10; i++) {
-    // 🔴 Bad: inside a loop (to fix, move it outside!)
+    // 🔴 Incorrect : au sein d’une boucle (pour corriger ça, sortez-en-le !)
     const theme = useContext(ThemeContext);
   }
   // ...
@@ -67,22 +67,22 @@ function Bad({ cond }) {
   if (cond) {
     return;
   }
-  // 🔴 Bad: after a conditional return (to fix, move it before the return!)
+  // 🔴 Incorrect : après un retour anticipé conditionnel (déplacez-le avant le return !)
   const theme = useContext(ThemeContext);
   // ...
 }
 
 function Bad() {
   function handleClick() {
-    // 🔴 Bad: inside an event handler (to fix, move it outside!)
+    // 🔴 Incorrect : au sein d’un gestionnaire d’événements (pour corriger ça, sortez-en-le !)
     const theme = useContext(ThemeContext);
   }
   // ...
 }
 
 function Bad() {
   const style = useMemo(() => {
-    // 🔴 Bad: inside useMemo (to fix, move it outside!)
+    // 🔴 Incorrect : au sein d’un useMemo (pour corriger ça, sortez-en-le !)
     const theme = useContext(ThemeContext);
     return createStyle(theme);
   });
@@ -91,47 +91,47 @@ function Bad() {
 
 class Bad extends React.Component {
   render() {
-    // 🔴 Bad: inside a class component (to fix, write a function component instead of a class!)
+    // 🔴 Incorrect : au sein d’un composant à base de classe (utilisez plutôt une fonction composant !)
     useEffect(() => {})
     // ...
   }
 }
 
 function Bad() {
   try {
-    // 🔴 Bad: inside try/catch/finally block (to fix, move it outside!)
+    // 🔴 Incorrect : au sein d’un bloc try/catch/finally block (pour corriger ça, sortez-en-le !)
     const [x, setX] = useState(0);
   } catch {
     const [x, setX] = useState(1);
   }
 }
 ```
 
-You can use the [`eslint-plugin-react-hooks` plugin](https://www.npmjs.com/package/eslint-plugin-react-hooks) to catch these mistakes.
+Vous pouvez utiliser le [plugin `eslint-plugin-react-hooks`](https://www.npmjs.com/package/eslint-plugin-react-hooks) pour repérer ces erreurs.
 
 <Note>
 
-[Custom Hooks](/learn/reusing-logic-with-custom-hooks) *may* call other Hooks (that's their whole purpose). This works because custom Hooks are also supposed to only be called while a function component is rendering.
+[Les Hooks personnalisés](/learn/reusing-logic-with-custom-hooks) *peuvent* appeler d'autres Hooks (c'est même leur raison d'être). Ça fonctionne parce que les Hooks personnalisés sont eux aussi censés n'être appelés que pendant la phase de rendu d'une fonction composant.
 
 </Note>
 
 ---
 
-## Only call Hooks from React functions {/*only-call-hooks-from-react-functions*/}
+## N'appelez des Hooks que depuis des fonctions React {/*only-call-hooks-from-react-functions*/}
 
-Don’t call Hooks from regular JavaScript functions. Instead, you can:
+N'appelez pas de Hooks depuis des fonctions JavaScript classiques.  Vous devriez plutôt :
 
-✅ Call Hooks from React function components.
-✅ Call Hooks from [custom Hooks](/learn/reusing-logic-with-custom-hooks#extracting-your-own-custom-hook-from-a-component).
+✅ Appeler des Hooks depuis des fonctions composants React.
+✅ Appeler des Hooks depuis des [Hooks personnalisés](/learn/reusing-logic-with-custom-hooks#extracting-your-own-custom-hook-from-a-component).
 
-By following this rule, you ensure that all stateful logic in a component is clearly visible from its source code.
+En suivant cette règle, vous garantissez que toute la logique à état d'un composant est clairement visible dans son code source.
 
 ```js {2,5}
 function FriendList() {
   const [onlineStatus, setOnlineStatus] = useOnlineStatus(); // ✅
 }
 
-function setOnlineStatus() { // ❌ Not a component or custom Hook!
+function setOnlineStatus() { // ❌ Ni un composant ni un Hook personnalisé !
   const [onlineStatus, setOnlineStatus] = useOnlineStatus();
 }
 ```