Merge branch 'working' into api/router-view.md

Author: Kocal

docs/en/SUMMARY.md

@@ -18,14 +18,14 @@
 - Avancé
   - [Navigation Guards (En)](advanced/navigation-guards.md)
   - [Route Meta Fields (En)](advanced/meta.md)
-  - [Transitions (En)](advanced/transitions.md)
+  - [Les transitions](advanced/transitions.md)
   - [Data Fetching (En)](advanced/data-fetching.md)
-  - [Scroll Behavior (En)](advanced/scroll-behavior.md)
+  - [Comportement du défilement](advanced/scroll-behavior.md)
   - [Lazy Loading (En)](advanced/lazy-loading.md)
 - Réference de l'API
   - [router-link (En)](api/router-link.md)
   - [router-view](api/router-view.md)
-  - [The Route Object (En)](api/route-object.md)
+  - [L'objet Route](api/route-object.md)
   - [Router Constructor Options (En)](api/options.md)
   - [Router Instance (En)](api/router-instance.md)
   - [Component Injections (En)](api/component-injections.md)

docs/en/advanced/scroll-behavior.md

@@ -1,40 +1,40 @@
-# Scroll Behavior (En) <br><br> *Cette page est en cours de traduction française. Revenez une autre fois pour lire une traduction achevée ou [participez à la traduction française ici](https://github.com/vuejs-fr/vue-router).*
+# Comportement du défilement
 
-When using client-side routing, we may want to scroll to top when navigating to a new route, or preserve the scrolling position of history entries just like real page reload does. `vue-router` allows you to achieve these and even better, allows you to completely customize the scroll behavior on route navigation.
+En utilisant le routage côté client, nous pourrions vouloir faire défiler la page jusqu'en haut lorsqu'on navigue vers une nouvelle route, ou alors préserver la position du défilement des entrées de l'historique comme le ferait une page réelle. `vue-router` vous permet de faire cela et, encore mieux, vous permet de changer le comportement du défilement pendant la navigation.
 
-**Note: this feature only works in HTML5 history mode.**
+**Note : cette fonctionnalité ne fonctionne qu'avec le mode historique HTML5.**
 
-When creating the router instance, you can provide the `scrollBehavior` function:
+Pendant la création de l'instance du routeur, vous pouvez renseigner la fonction `scrollBehavior` :
 
 ``` js
 const router = new VueRouter({
   routes: [...],
   scrollBehavior (to, from, savedPosition) {
-    // return desired position
+    // retourner la position désirée
   }
 })
 ```
 
-The `scrollBehavior` function receives the `to` and `from` route objects. The third argument, `savedPosition`, is only available if this is a `popstate` navigation (triggered by the browser's back/forward buttons).
+La fonction `scrollBehavior` reçoit les objets de route `to` et `from`. Le troisième argument, `savedPosition`, est disponible uniquement si c'est une navigation `popstate` (déclenchée par les boutons précédent/suivant du navigateur).
 
-The function can return a scroll position object. The object could be in the form of:
+La fonction peut retourner un objet décrivant la position du défilement. L'objet peut être de la forme :
 
-- `{ x: number, y: number }`
-- `{ selector: string }`
+-  `{ x: number, y: number }`
+- `{ selector: String }`
 
-If a falsy value or an empty object is returned, no scrolling will happen.
+Si une valeur équivalente à `false` ou un objet vide est retourné, aucun défilement ne sera produit.
 
-For example:
+Par exemple : 
 
 ``` js
 scrollBehavior (to, from, savedPosition) {
   return { x: 0, y: 0 }
 }
 ```
 
-This will simply make the page scroll to top for all route navigations.
+Cela permettra de défiler au haut de page à chaque navigation à travers les routes.
 
-Returning the `savedPosition` will result in a native-like behavior when navigating with back/forward buttons:
+Retourner l'objet `savedPosition` résultera en un comportement quasi-natif en naviguant avec les boutons précédents/suivants :
 
 ``` js
 scrollBehavior (to, from, savedPosition) {
@@ -46,7 +46,7 @@ scrollBehavior (to, from, savedPosition) {
 }
 ```
 
-If you want to simulate the "scroll to anchor" behavior:
+Si vous voulez simuler le comportement « aller à l'ancre » :
 
 ``` js
 scrollBehavior (to, from, savedPosition) {
@@ -58,4 +58,4 @@ scrollBehavior (to, from, savedPosition) {
 }
 ```
 
-We can also use [route meta fields](meta.md) to implement fine-grained scroll behavior control. Check out a full example [here](https://github.com/vuejs/vue-router/blob/dev/examples/scroll-behavior/app.js).
+On peut aussi utiliser les [champs meta de route](meta.md) pour implémenter un contrôle bien précis pour le comportement du défilement. Allez voir un exemple complet [ici](https://github.com/vuejs/vue-router/blob/dev/examples/scroll-behavior/app.js).

docs/en/advanced/transitions.md

@@ -1,18 +1,18 @@
-# Transitions (En) <br><br> *Cette page est en cours de traduction française. Revenez une autre fois pour lire une traduction achevée ou [participez à la traduction française ici](https://github.com/vuejs-fr/vue-router).*
+# Les transitions
 
-Since the `<router-view>` is essentially a dynamic component, we can apply transition effects to it the same way using the `<transition>` component:
+Vu que `<router-view>` est essentiellement un composant dynamique, on peut lui appliquer certains effets de transitions en utilisant le composant `<transition>` :
 
 ``` html
 <transition>
   <router-view></router-view>
 </transition>
 ```
 
-[Everything about `<transition>`](http://vuejs.org/guide/transitions.html) works the same here.
+[Tout à propos de `<transition>`](http://fr.vuejs.org/v2/guide/transitions.html) fonctionne également ici de la même manière.
 
-### Per-Route Transition
+### Transition par route
 
-The above usage will apply the same transition for all routes. If you want each route's component to have different transitions, you can instead use `<transition>` with different names inside each route component:
+L'utilisation au dessus applique la même transition pour chaque route. Si vous voulez que les composants de route aient des transitions différentes, vous pouvez utiliser à la place `<transition>` avec des noms différents à l'intérieur de chaque composant de route :
 
 ``` js
 const Foo = {
@@ -32,20 +32,20 @@ const Bar = {
 }
 ```
 
-### Route-Based Dynamic Transition
+# Transition dynamique basée sur la route
 
-It is also possible to determine the transition to use dynamically based on the relationship between the target route and current route:
+Il est aussi possible de déterminer la transition à utiliser en se basant sur la relation entre la route cible et la route actuelle :
 
 ``` html
-<!-- use a dynamic transition name -->
+<!-- utiliser un nom de transition dynamique -->
 <transition :name="transitionName">
   <router-view></router-view>
 </transition>
 ```
 
 ``` js
-// then, in the parent component,
-// watch the $route to determine the transition to use
+// et dans le composant parent,
+// observer la `$route` pour déterminer la transition à utiliser
 watch: {
   '$route' (to, from) {
     const toDepth = to.path.split('/').length
@@ -55,4 +55,4 @@ watch: {
 }
 ```
 
-See full example [here](https://github.com/vuejs/vue-router/blob/dev/examples/transitions/app.js).
+Voir un exemple complet [ici](https://github.com/vuejs/vue-router/blob/dev/examples/transitions/app.js).

docs/en/api/route-object.md

@@ -1,89 +1,89 @@
-# The Route Object (En) <br><br> *Cette page est en cours de traduction française. Revenez une autre fois pour lire une traduction achevée ou [participez à la traduction française ici](https://github.com/vuejs-fr/vue-router).*
+# L'objet `Route`
 
-A **route object** represents the state of the current active route. It contains parsed information of the current URL and the **route records** matched by the URL.
+Un **objet `Route`** représente l'état actuel de la route active. Il contient des informations analysées à propos de l'URL courante et **les itinéraires de route** appariés par l'URL.
 
-The route object is immutable. Every successful navigation will result in a fresh route object.
+L'objet `Route` est immutable. Chaque navigation qui se déroule avec succès résultera en un nouvel objet `Route`.
 
-The route object can be found in multiple places:
+L'objet `Route` peut être trouvé à plusieurs endroits :
 
-- Inside components as `this.$route`
+- À l'intérieur des composants en tant que `this.$route`
 
-- Inside `$route` watcher callbacks
+- À l'intérieur des fonctions de rappel des observateurs de `$route`
 
-- As the return value of calling `router.match(location)`
+- Comme valeur de retour après l'appel de `router.match(location)`
 
-- Inside navigation guards as the first two arguments:
+- À l'intérieur des fonctions de sécurisation de la navigation, dans les deux premiers paramètres de la fonction :
 
   ``` js
   router.beforeEach((to, from, next) => {
-    // to and from are both route objects
+    // `to` et `from` sont tous les deux des objets Route
   })
   ```
 
-- Inside the `scrollBehavior` function as the first two arguments:
+- À l'intérieur de la fonction `scrollBehavior` dans les deux premiers arguments :
 
   ``` js
   const router = new VueRouter({
     scrollBehavior (to, from, savedPosition) {
-      // to and from are both route objects
+      // `to` et `from` sont tous les deux des objets Route
     }
   })
   ```
 
-### Route Object Properties
+### Propriétés de l'objet `Route`
 
 - **$route.path**
 
-  - type: `string`
+  - type : `string`
 
-    A string that equals the path of the current route, always resolved as an absolute path. e.g. `"/foo/bar"`.
+    Une chaîne de caractères représentant le chemin de la route en cours, toujours résolue en tant que chemin absolu, ex : `"/foo/bar"`.
 
 - **$route.params**
 
-  - type: `Object`
+  - type : `Object`
 
-    An object that contains key/value pairs of dynamic segments and star segments. If there are no params the value will be an empty object.
+    Un objet qui contient des pairs clé/valeur de segments dynamiques et segments *star*. S'il n'y a pas de paramètres, alors la valeur sera un objet vide.
 
 - **$route.query**
 
-  - type: `Object`
-
-    An object that contains key/value pairs of the query string. For example, for a path `/foo?user=1`, we get `$route.query.user == 1`. If there is no query the value will be an empty object.
+  - type : `Object`
 
+    Un objet qui contient des pairs clé/valeur de la requête au format d'une chaîne de caractères. Par exemple, pour un chemin `/foo?user=1`, on aura `$route.query.user == 1`. S'il n'y a pas de requête, alors la valeur sera un objet vide.
+    
 - **$route.hash**
 
-  - type: `string`
+  - type : `string`
 
-    The hash of the current route (with the `#`), if it has one. If no hash is present the value will be an empty string.
+    Le hash de la route courante (avec le `#`), s'il y en a un. S'il n'y a pas de hash, alors la valeur sera une chaîne de caractères vide.
 
 - **$route.fullPath**
 
-  - type: `string`
+  - type : `string`
 
-    The full resolved URL including query and hash.
+    L'URL entièrement résolue, incluant la requête et le hash.
 
 - **$route.matched**
 
-  - type: `Array<RouteRecord>`
+  - type : `Array<RouteRecord>`
 
-  An Array containing **route records** for all nested path segments of the current route. Route records are the copies of the objects in the `routes` configuration Array (and in `children` Arrays):
+    Un `Array` contenant les **les itinéraires de la route** pour chaque segment de chemin imbriqué de la route courante. Les itinéraires de la route sont des copies des objets dans le tableau de configuration `routes` (et dans les tableaux `children`).
 
   ``` js
   const router = new VueRouter({
     routes: [
-      // the following object is a route record
+      // l'objet qui suit est un itinéraire de route
       { path: '/foo', component: Foo,
         children: [
-          // this is also a route record
+          // c'est aussi un itinéraire
           { path: 'bar', component: Bar }
         ]
       }
     ]
   })
   ```
 
-  When the URL is `/foo/bar`, `$route.matched` will be an Array containing both objects (cloned), in parent to child order.
+  Lorsque l'URL sera `/foo/bar`, `$route.matched` sera un `Array` contenant les deux objets (clonés), dans l'ordre parent à l'enfant.
 
 - **$route.name**
 
-  The name of the current route, if it has one. (See [Named Routes](../essentials/named-routes.md))
+  Le nom de la route courante, si elle en a un. (Voir [Routes nommées](../essentials/named-routes.md)).