FR translation: translate files

Author: nfabredev

docs/playground/fr/3-7/Syntax and Messaging/Flattened Error Reporting.ts

@@ -1,23 +1,23 @@
 //// { compiler: {  }, order: 3 }
 
-// TypeScript's error messages can sometimes be a tad verbose...
-// With 3.7, we've taken a few cases which could be particularly
-// egregious.
+// Les messages d'erreur TypeScript peuvent être un peu verbeux...
+// Avec la version 3.7, nous avons corrigé quelques cas qui
+// généraient des messages d'erreurs très longs.
 
-// Nested Properties
+// Propriétés imbriquées
 
 let a = { b: { c: { d: { e: "string" } } } };
 let b = { b: { c: { d: { e: 12 } } } };
 
 a = b;
 
-// Before, it was 2 lines of code per nested property, which
-// quickly meant people learned to read error messages by
-// reading the first and then last line of an error message.
+// Auparavant, c'était deux lignes de code par propriété imbriquée, ce qui
+// a rapidement amené les gens à lire
+// uniquement la première et dernière ligne des messages d'erreur.
 
-// Now they're inline. :tada:
+// Maintenant elles sont en ligne. :tada:
 
-// Previously in 3.6:
+// Auparavant avec la version 3.6:
 //
 // Type '{ b: { c: { d: { e: number; }; }; }; }' is not assignable to type '{ b: { c: { d: { e: string; }; }; }; }'.
 //   Types of property 'b' are incompatible.
@@ -29,8 +29,8 @@ a = b;
 //               Types of property 'e' are incompatible.
 //                 Type 'number' is not assignable to type 'string'
 
-// This can handle working through different types of objects,
-// to still give a useful and concise error message.
+// Ça peut aussi marcher avec des objets de types différents
+// et toujours donner un message d'erreur utile et concis.
 
 class ExampleClass {
   state = "ok";
@@ -44,7 +44,7 @@ let x = { a: { b: { c: { d: { e: { f: ExampleClass } } } } } };
 let y = { a: { b: { c: { d: { e: { f: OtherClass } } } } } };
 x = y;
 
-// Previously in 3.6:
+// Auparavant avec la version 3.6:
 //
 // Type '{ a: { b: { c: { d: { e: { f: typeof OtherClass; }; }; }; }; }; }' is not assignable to type '{ a: { b: { c: { d: { e: { f: typeof ExampleClass; }; }; }; }; }; }'.
 //   Types of property 'a' are incompatible.

docs/playground/fr/3-7/Syntax and Messaging/Nullish Coalescing.ts

@@ -1,43 +1,45 @@
 //// { compiler: {  }, order: 2 }
 
-// The nullish coalescing operator is an alternative to ||
-// which returns the right-side expression if the left-side
-// is null or undefined.
+// L'opérateur de coalescence des nuls (nullish coalescing operator) est une
+// alternative à || qui retourne l'expression de droite si celle de gauche
+// est nulle ou non-définie.
 
-// In contrast, || uses falsy checks, meaning an empty
-// string or the number 0 would be considered false.
+// En revanche, || vérifie si la valeur est de type fausse (falsy), ce qui veut dire
+// qu'une chaîne de caractères, ou le nombre 0, seraient considérés faux.
 
-// A good example for this feature is dealing with partial
-// objects which have defaults when a key isn't passed in.
+// Un bon example est la gestion des objets partiellement
+// définis, pour lesquels il est possible d'avoir des valeurs par défaut
+// quand une clef est manquante.
 
 interface AppConfiguration {
-  // Default: "(no name)"; empty string IS valid
+  // Défaut: "(no name)"; une chaîne de caractère vide est une valeur valide
   name: string;
 
-  // Default: -1; 0 is valid
+  // Défaut: -1; 0 est une valeur valide
   items: number;
 
-  // Default: true
+  // Défaut: true
   active: boolean;
 }
 
 function updateApp(config: Partial<AppConfiguration>) {
-  // With null-coalescing operator
+  // Avec l'opérateur de coalescence des nuls
   config.name = config.name ?? "(no name)";
   config.items = config.items ?? -1;
   config.active = config.active ?? true;
 
-  // Current solution
+  // Sans l'opérateur de coalescence des nuls
   config.name = typeof config.name === "string" ? config.name : "(no name)";
   config.items = typeof config.items === "number" ? config.items : -1;
   config.active = typeof config.active === "boolean" ? config.active : true;
 
-  // Using || operator which could give bad data
-  config.name = config.name || "(no name)"; // does not allow for "" input
-  config.items = config.items || -1; // does not allow for 0 input
-  config.active = config.active || true; // really bad, always true
+  // L'opérateur || pourrait retourner des valeurs incorrectes
+  config.name = config.name || "(no name)"; // empêche de passer "" comme valeur
+  config.items = config.items || -1; // empêche de passer 0 comme valeur
+  config.active = config.active || true; // incorrect, sera toujours true
 }
 
-// You can read more about nullish coalescing in the 3.7 blog post:
+// Plus de détails sur l'opérateur de coalescence des nuls dans la version 3.7
+// sur le blog:
 //
 // https://devblogs.microsoft.com/typescript/announcing-typescript-3-7/

docs/playground/fr/3-7/Syntax and Messaging/Optional Chaining.ts

@@ -1,15 +1,14 @@
 //// { compiler: {  }, order: 1 }
 
-// Optional chaining reached TC39 Stage 3 consensus during
-// 3.7's development. Optional Chaining allows you to write
-// code which can immediately stop running expressions when
-// it hits a null or undefined.
+// Le chaînage optionnel a atteint l'étape 3 du TC39 pendant le development
+// de la version 3.7. Le chaînage optionnel permet d'écrire du code qui va
+// interrompre l'execution des expressions dès qu'il atteint une valeur
+// null ou undefined.
 
-// Property Access
+// Accès aux propriétés d'un objet
 
-// Let's imagine we have an album where the artist, and the
-// artists bio might not be present in the data. For example
-// a compilation may not have a single artist.
+// Imaginons que nous ayons un album où l'artiste, et sa bio, puissent ne pas
+// être present dans les données. Par exemple, une compilation pourrait n'aurait pas un seul artiste.
 
 type AlbumAPIResponse = {
   title: string;
@@ -22,40 +21,40 @@ type AlbumAPIResponse = {
 
 declare const album: AlbumAPIResponse;
 
-// With optional chaining, you can write
-// code like this:
+// Avec le chaînage optionnel,
+// vous pouvez écrire le code suivant:
 
 const artistBio = album?.artist?.bio;
 
-// Instead of:
+// A la place de:
 
 const maybeArtistBio = album.artist && album.artist.bio;
 
-// In this case ?. acts differently than the &&s since &&
-// will act differently on "falsy" values (e.g. an empty string,
-// 0, NaN, and, well, false).
+// Dans ce cas ?. agit différemment que le ET logique (&&) car ce dernier traite
+// les valeur fausses (e.g. une chaîne de caractères vide, 0, Nan et false) de
+// façon différente.
 
-// Optional chaining will only take null or undefined as
-// a signal to stop and return an undefined.
+// Le chaînage optionnel va seulement arrêter l'évaluation et retourner undefined
+// si la valeur est null ou undefined.
 
-// Optional Element Access
+// Accès à un élément optionnel
 
-// Property access is via the . operator, the optional chaining
-// also works with the [] operators when accessing elements.
+// Acceder à une propriété se fait avec l'opérateur ., et le chaînage optionnel
+// marche aussi avec l'opérateur [] pour acceder à des éléments.
 
 const maybeArtistBioElement = album?.["artist"]?.["bio"];
 
 const maybeFirstPreviousAlbum = album?.artist?.previousAlbums?.[0];
 
-// Optional Calls
+// Appel optionnel
 
-// When dealing with functions which may or may not exist at
-// runtime, optional chaining supports only calling a function
-// if it exists. This can replace code where you would traditionally
-// write something like: if (func) func()
+// Quand il s'agit d'appeler des fonctions qui peuvent être définies ou non définies,
+// le chaînage optionnel permet d'appeler la fonction uniquement si elle existe.
+// Cela peut remplacer le code où l'on écrirait traditionnellement quelque chose comme:
+// if (func) func()
 
-// For example here's an optional call to the callback from
-// an API request:
+// Par example le chaînage optionnel pour appeler un callback après une requête
+// vers une API:
 
 const callUpdateMetadata = (metadata: any) => Promise.resolve(metadata); // Fake API call
 
@@ -65,6 +64,6 @@ const updateAlbumMetadata = async (metadata: any, callback?: () => void) => {
   callback?.();
 };
 
-// You can read more about optional chaining in the 3.7 blog post:
+// Plus de détails sur le chaînage optionnel dans la version 3.7 sur le blog:
 //
 // https://devblogs.microsoft.com/typescript/announcing-typescript-3-7/