copy(preloadModule): translate preloadModule() page

Author: tdd

src/content/reference/react-dom/preload.md

@@ -73,7 +73,7 @@ La fonction `preload` suggère au navigateur de commencer à télécharger une r
 * Plusieurs appels équivalents à `preload` ont le même effet qu'un unique appel. Des appels à `preload` sont considérés équivalents selon les règles que voici :
   * Deux appels sont équivalents s'ils ont le même `href`, sauf si :
   * L'option `as` vaut `image`, auquel cas les deux appels sont équivalents s'ils ont les mêmes `href`, `imageSrcSet` et `imageSizes`.
-* Côté client, vous pouvez appeler `preinit` n'importe où : lors du rendu d'un composant, dans un Effet, dans un gestionnaire d'événement, etc.
+* Côté client, vous pouvez appeler `preload` n'importe où : lors du rendu d'un composant, dans un Effet, dans un gestionnaire d'événement, etc.
 * Lors d'un rendu côté serveur ou du rendu de Composants Serveur, `preload` n'a d'effet que si vous l'appelez lors du rendu d'un composant ou dans une fonction asynchrone issue du rendu d'un composant.  Tout autre appel sera ignoré.
 
 ---

src/content/reference/react-dom/preloadModule.md

@@ -5,22 +5,22 @@ canary: true
 
 <Canary>
 
-The `preloadModule` function is currently only available in React's Canary and experimental channels. Learn more about [React's release channels here](/community/versioning-policy#all-release-channels).
+La fonction `preloadModule` n'est actuellement disponible que sur les canaux de livraison Canary et Expérimental de React. Apprenez-en davantage sur [les canaux de livraison React](/community/versioning-policy#all-release-channels).
 
 </Canary>
 
 <Note>
 
-[React-based frameworks](/learn/start-a-new-react-project) frequently handle resource loading for you, so you might not have to call this API yourself. Consult your framework's documentation for details.
+[Les frameworks basés sur React](/learn/start-a-new-react-project) s'occupent fréquemment pour vous du chargement des ressources, de sorte que vous n'aurez peut-être pas besoin d'appeler ces API vous-même.  Consultez la documentation de votre framework pour en savoir plus à ce sujet.
 
 </Note>
 
 <Intro>
 
-`preloadModule` lets you eagerly fetch an ESM module that you expect to use.
+`preloadModule` vous permet de charger en avance un module ESM que vous avez l'intention d'utiliser.
 
 ```js
-preloadModule("https://example.com/module.js", {as: "script"});
+preloadModule("https://example.com/module.js", { as: "script" });
 ```
 
 </Intro>
@@ -29,79 +29,78 @@ preloadModule("https://example.com/module.js", {as: "script"});
 
 ---
 
-## Reference {/*reference*/}
+## Référence {/*reference*/}
 
 ### `preloadModule(href, options)` {/*preloadmodule*/}
 
-To preload an ESM module, call the `preloadModule` function from `react-dom`.
+Pour précharger un module ESM, appelez la fonction `preloadModule` de `react-dom`.
 
 ```js
 import { preloadModule } from 'react-dom';
 
 function AppRoot() {
-  preloadModule("https://example.com/module.js", {as: "script"});
+  preloadModule("https://example.com/module.js", { as: "script" });
   // ...
 }
 
 ```
 
-[See more examples below.](#usage)
+[Voir d'autres exemples plus bas](#usage).
 
-The `preloadModule` function provides the browser with a hint that it should start downloading the given module, which can save time.
+La fonction `preloadModule` suggère au navigateur de commencer à télécharger un module donné, ce qui peut faire gagner du temps.
 
-#### Parameters {/*parameters*/}
+#### Paramètres {/*parameters*/}
 
-* `href`: a string. The URL of the module you want to download.
-* `options`: an object. It contains the following properties:
-  *  `as`: a required string. It must be `'script'`.
-  *  `crossOrigin`: a string. The [CORS policy](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/crossorigin) to use. Its possible values are `anonymous` and `use-credentials`.
-  *  `integrity`: a string. A cryptographic hash of the module, to [verify its authenticity](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity).
-  *  `nonce`: a string. A cryptographic [nonce to allow the module](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/nonce) when using a strict Content Security Policy. 
+* `href` : une chaîne de caractères. L'URL du module que vous souhaitez télécharger.
+* `options` : un objet. Il contient les propriétés suivantes :
+  *  `as` : une chaîne de caractères obligatoire. Doit être `'script'`.
+  *  `crossOrigin` : une chaîne de caractères. La [politique CORS](https://developer.mozilla.org/fr/docs/Web/HTML/Attributes/crossorigin) à utiliser. Les valeurs possibles sont `anonymous` et `use-credentials`.
+  * `integrity` : une chaîne de caractères. Une empreinte cryptographique du module afin de [vérifier son authenticité](https://developer.mozilla.org/fr/docs/Web/Security/Subresource_Integrity).
+  * `nonce` : une chaîne de caractères. Un [nonce cryptographique autorisant le module](https://developer.mozilla.org/fr/docs/Web/HTML/Global_attributes/nonce) dans le cadre d'une Politique de Sécurité de Contenu (CSP) stricte.
 
+#### Valeur renvoyée {/*returns*/}
 
-#### Returns {/*returns*/}
+`preloadModule` ne renvoie rien.
 
-`preloadModule` returns nothing.
+#### Limitations {/*caveats*/}
 
-#### Caveats {/*caveats*/}
-
-* Multiple calls to `preloadModule` with the same `href` have the same effect as a single call.
-* In the browser, you can call `preloadModule` in any situation: while rendering a component, in an effect, in an event handler, and so on.
-* In server-side rendering or when rendering Server Components, `preloadModule` only has an effect if you call it while rendering a component or in an async context originating from rendering a component. Any other calls will be ignored.
+* Plusieurs appels à `preloadModule` avec le même `href` ont le même effet qu'un unique appel.
+* Côté client, vous pouvez appeler `preloadModule` n'importe où : lors du rendu d'un composant, dans un Effet, dans un gestionnaire d'événement, etc.
+* Lors d'un rendu côté serveur ou du rendu de Composants Serveur, `preloadModule` n'a d'effet que si vous l'appelez lors du rendu d'un composant ou dans une fonction asynchrone issue du rendu d'un composant.  Tout autre appel sera ignoré.
 
 ---
 
-## Usage {/*usage*/}
+## Utilisation {/*usage*/}
 
-### Preloading when rendering {/*preloading-when-rendering*/}
+### Précharger lors du rendu {/*preloading-when-rendering*/}
 
-Call `preloadModule` when rendering a component if you know that it or its children will use a specific module.
+Appelez `preloadModule` lors du rendu d'un composant si vous savez que ses enfants auront besoin de charger un module spécifique.
 
 ```js
 import { preloadModule } from 'react-dom';
 
 function AppRoot() {
-  preloadModule("https://example.com/module.js", {as: "script"});
+  preloadModule("https://example.com/module.js", { as: "script" });
   return ...;
 }
 ```
 
-If you want the browser to start executing the module immediately (rather than just downloading it), use [`preinitModule`](/reference/react-dom/preinitModule) instead. If you want to load a script that isn't an ESM module, use [`preload`](/reference/react-dom/preload).
+Si vous souhaitez que le navigateur évalue le module immédiatement après chargement (plutôt que simplement le charger), utilisez plutôt [`preinitModule`](/reference/react-dom/preinitModule). Si vous souhaitez charger un script qui n'est pas un module ESM, utilisez [`preload`](/reference/react-dom/preload).
 
-### Preloading in an event handler {/*preloading-in-an-event-handler*/}
+### Précharger dans un gestionnaire d'événement {/*preloading-in-an-event-handler*/}
 
-Call `preloadModule` in an event handler before transitioning to a page or state where the module will be needed. This gets the process started earlier than if you call it during the rendering of the new page or state.
+Appelez `preloadModule` depuis un gestionnaire d'événement avant de passer à une page ou un état qui auront besoin du module.  Ça permet de déclencher le processus plus tôt que si vous l'appeliez au sein de la nouvelle page ou suite au nouvel état.
 
 ```js
 import { preloadModule } from 'react-dom';
 
 function CallToAction() {
   const onClick = () => {
-    preloadModule("https://example.com/module.js", {as: "script"});
+    preloadModule("https://example.com/module.js", { as: "script" });
     startWizard();
   }
   return (
-    <button onClick={onClick}>Start Wizard</button>
+    <button onClick={onClick}>Démarrer l’assistant</button>
   );
 }
 ```