FR translation: copy folder to translate

Author: nfabredev

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

@@ -0,0 +1,64 @@
+//// { 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.
+
+// Nested Properties
+
+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.
+
+// Now they're inline. :tada:
+
+// Previously in 3.6:
+//
+// Type '{ b: { c: { d: { e: number; }; }; }; }' is not assignable to type '{ b: { c: { d: { e: string; }; }; }; }'.
+//   Types of property 'b' are incompatible.
+//     Type '{ c: { d: { e: number; }; }; }' is not assignable to type '{ c: { d: { e: string; }; }; }'.
+//       Types of property 'c' are incompatible.
+//         Type '{ d: { e: number; }; }' is not assignable to type '{ d: { e: string; }; }'.
+//           Types of property 'd' are incompatible.
+//             Type '{ e: number; }' is not assignable to type '{ e: string; }'.
+//               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.
+
+class ExampleClass {
+  state = "ok";
+}
+
+class OtherClass {
+  state = 12;
+}
+
+let x = { a: { b: { c: { d: { e: { f: ExampleClass } } } } } };
+let y = { a: { b: { c: { d: { e: { f: OtherClass } } } } } };
+x = y;
+
+// Previously in 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.
+//     Type '{ b: { c: { d: { e: { f: typeof OtherClass; }; }; }; }; }' is not assignable to type '{ b: { c: { d: { e: { f: typeof ExampleClass; }; }; }; }; }'.
+//       Types of property 'b' are incompatible.
+//         Type '{ c: { d: { e: { f: typeof OtherClass; }; }; }; }' is not assignable to type '{ c: { d: { e: { f: typeof ExampleClass; }; }; }; }'.
+//           Types of property 'c' are incompatible.
+//             Type '{ d: { e: { f: typeof OtherClass; }; }; }' is not assignable to type '{ d: { e: { f: typeof ExampleClass; }; }; }'.
+//               Types of property 'd' are incompatible.
+//                 Type '{ e: { f: typeof OtherClass; }; }' is not assignable to type '{ e: { f: typeof ExampleClass; }; }'.
+//                   Types of property 'e' are incompatible.
+//                     Type '{ f: typeof OtherClass; }' is not assignable to type '{ f: typeof ExampleClass; }'.
+//                       Types of property 'f' are incompatible.
+//                         Type 'typeof OtherClass' is not assignable to type 'typeof ExampleClass'.
+//                           Type 'OtherClass' is not assignable to type 'ExampleClass'.
+//                             Types of property 'state' are incompatible.
+//                               Type 'number' is not assignable to type 'string'

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

@@ -0,0 +1,43 @@
+//// { 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.
+
+// In contrast, || uses falsy checks, meaning an empty
+// string or the number 0 would be considered false.
+
+// A good example for this feature is dealing with partial
+// objects which have defaults when a key isn't passed in.
+
+interface AppConfiguration {
+  // Default: "(no name)"; empty string IS valid
+  name: string;
+
+  // Default: -1; 0 is valid
+  items: number;
+
+  // Default: true
+  active: boolean;
+}
+
+function updateApp(config: Partial<AppConfiguration>) {
+  // With null-coalescing operator
+  config.name = config.name ?? "(no name)";
+  config.items = config.items ?? -1;
+  config.active = config.active ?? true;
+
+  // Current solution
+  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
+}
+
+// You can read more about nullish coalescing in the 3.7 blog post:
+//
+// https://devblogs.microsoft.com/typescript/announcing-typescript-3-7/

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

@@ -0,0 +1,70 @@
+//// { 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.
+
+// Property Access
+
+// 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.
+
+type AlbumAPIResponse = {
+  title: string;
+  artist?: {
+    name: string;
+    bio?: string;
+    previousAlbums?: string[];
+  };
+};
+
+declare const album: AlbumAPIResponse;
+
+// With optional chaining, you can write
+// code like this:
+
+const artistBio = album?.artist?.bio;
+
+// Instead of:
+
+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).
+
+// Optional chaining will only take null or undefined as
+// a signal to stop and return an undefined.
+
+// Optional Element Access
+
+// Property access is via the . operator, the optional chaining
+// also works with the [] operators when accessing elements.
+
+const maybeArtistBioElement = album?.["artist"]?.["bio"];
+
+const maybeFirstPreviousAlbum = album?.artist?.previousAlbums?.[0];
+
+// Optional Calls
+
+// 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()
+
+// For example here's an optional call to the callback from
+// an API request:
+
+const callUpdateMetadata = (metadata: any) => Promise.resolve(metadata); // Fake API call
+
+const updateAlbumMetadata = async (metadata: any, callback?: () => void) => {
+  await callUpdateMetadata(metadata);
+
+  callback?.();
+};
+
+// You can read more about optional chaining in the 3.7 blog post:
+//
+// https://devblogs.microsoft.com/typescript/announcing-typescript-3-7/