docs(vuepress): move 🇫🇷 doc in vuepress

docs/.vuepress/config.js

@@ -29,6 +29,11 @@ module.exports = {
       lang: 'pt-BR',
       title: 'Vuex',
       description: 'Gerenciamento de Estado Centralizado para Vue.js'
+    },
+    '/fr/': {
+        lang: 'fr-FR',
+        title: 'Vuex',
+        description: 'Gestion d\'état centralisé pour Vue.js'
     }
   },
   serviceWorker: true,
@@ -280,7 +285,48 @@ module.exports = {
           '/ptbr/guide/testing',
           '/ptbr/guide/hot-reload'
         ]
-      }
+      },
+      '/fr/': {
+          label: 'Français',
+          selectText: 'Langues',
+          editLinkText: 'Éditer la page sur GitHub',
+          nav: [
+              {
+                  text: 'Guide',
+                  link: '/guide/'
+              },
+              {
+                  text: 'API',
+                  link: '/api/'
+              },
+              {
+                  text: 'Notes de release',
+                  link: 'https://github.com/vuejs/vuex/releases'
+              }
+          ],
+          sidebar: [
+              '/fr/installation',
+              '/fr/',
+              '/fr/guide/',
+              {
+                  title: 'Concepts centraux',
+                  collapsable: false,
+                  children: [
+                      '/fr/guide/state',
+                      '/fr/guide/getters',
+                      '/fr/guide/mutations',
+                      '/fr/guide/actions',
+                      '/fr/guide/modules'
+                  ]
+              },
+              '/fr/guide/structure',
+              '/fr/guide/plugins',
+              '/fr/guide/strict',
+              '/fr/guide/forms',
+              '/fr/guide/testing',
+              '/fr/guide/hot-reload'
+          ]
+      },
     }
   }
 }

docs/fr/README.md

@@ -0,0 +1,63 @@
+# Vuex, qu'est-ce que c'est ?
+
+Vuex est un **_gestionnaire d'état (« state management pattern »)_ et une bibliothèque** pour des applications Vue.js. Il sert de zone de stockage de données centralisée pour tous les composants dans une application, avec des règles pour s'assurer que l'état ne puisse subir de mutations que d'une manière prévisible. Il s'intègre également avec [l'extension officielle](https://github.com/vuejs/vue-devtools) de Vue afin de fournir des fonctionnalités avancées comme de la visualisation d'état dans le temps et des exports et imports d’instantanés (« snapshot ») d'état.
+
+### Un « gestionnaire d'état », qu'est-ce que c'est ?
+
+Commençons par une simple application de comptage avec Vue :
+
+``` js
+new Vue({
+  // état
+  data () {
+    return {
+      count: 0
+    }
+  },
+  // vue
+  template: `
+    <div>{{ count }}</div>
+  `,
+  // actions
+  methods: {
+    increment () {
+      this.count++
+    }
+  }
+})
+```
+
+C'est une application autosuffisante avec les parties suivantes :
+
+- L'**état**, qui est la source de vérité qui pilote votre application,
+- La **vue**, qui est une réflexion déclarative de l'**état**,
+- Les **actions**, qui sont les façons possibles pour l'état de changer en réaction aux actions utilisateurs depuis la **vue**.
+
+Voici une représentation extrêmement simple du concept de « flux de donnée unidirectionnel » :
+
+<p style="text-align: center; margin: 2em">
+  <img style="width:100%;max-width:450px;" src="/flow.png">
+</p>
+
+Cependant, la simplicité s'évapore rapidement lorsque nous avons **de multiples composants qui partagent un même état global** :
+
+- Plusieurs vues peuvent dépendre de la même partie de l'état global.
+- Des actions dans différentes vues peuvent avoir besoin de muter la même partie de l'état global.
+
+Pour le premier problème, passer des props peut être fastidieux pour les composants profondément imbriqués, et ça ne fonctionne tout simplement pas pour les composants d'un même parent. Pour le deuxième problème, on se retrouve souvent à se rabattre sur des solutions telles qu'accéder aux références d'instance du parent/enfant direct ou essayer de muter et synchroniser de multiples copies de l'état via des évènements. Ces deux modèles sont fragiles et posent rapidement des problèmes de maintenabilité du code.
+
+Alors pourquoi ne pas extraire l'état global partagé des composants, et le gérer dans un singleton global ? De cette manière, notre arbre de composant devient une grosse « vue », et n'importe quel composant peut accéder à l'état global ou déclencher des actions, peu importe où il se trouve dans l'arbre !
+
+De plus, en définissant et en séparant les concepts impliqués dans la gestion de l'état global et en appliquant certaines règles, on donne aussi une structure et une maintenabilité à notre code.
+
+Voilà l'idée de base derrière Vuex, inspiré par [Flux](https://facebook.github.io/flux/docs/overview.html), [Redux](http://redux.js.org/) et [l'architecture Elm](https://guide.elm-lang.org/architecture/). À l'inverse des autres modèles, Vuex est aussi une bibliothèque d'implémentation conçue spécialement pour Vue.js afin de bénéficier de son système de réactivité granulaire pour des modifications efficaces.
+
+![vuex](/vuex.png)
+
+### Quand l'utiliser ?
+
+Bien que Vuex nous aide à gérer un état global partagé, il apporte aussi le cout de nouveaux concepts et _abstraction de code_ (« boilerplate »). C'est un compromis entre la productivité à court terme et à long terme.
+
+Si vous n'avez jamais créé une _application monopage_ à grande échelle et que vous sautez directement dans Vuex, cela peut paraitre verbeux et intimidant. C'est parfaitement normal ; si votre application est simple, vous vous en sortirez sans doute très bien sans Vuex. Un simple [canal d'évènement global](https://fr.vuejs.org/v2/guide/components.html#Communication-non-parent-enfant) pourrait très bien vous suffire. Mais si vous devez créer une application monopage à moyenne ou grande échelle, il y a des chances que vous vous trouviez dans des situations qui vous feront vous interroger sur une meilleure gestion de l'état global, détaché de votre composant Vue, et Vuex sera naturellement la prochaine étape pour vous. Voici une bonne citation de Dan Abramov, l'auteur de Redux :
+
+> « Les librairies Flux, c'est comme les lunettes : vous saurez quand vous en aurez besoin. »

docs/fr/api/README.md

@@ -0,0 +1,251 @@
+---
+sidebar: auto
+---
+
+# Documentation de l'API
+
+## Vuex.Store
+
+``` js
+import Vuex from 'vuex'
+
+const store = new Vuex.Store({ ...options })
+```
+
+## Options du constructeur de `Vuex.Store`
+
+### state
+
+  - type : `Object | Function`
+
+    L'objet d'état racine pour le store Vuex. [Plus de détails](../guide/state.md)
+
+    Si vous passez une fonction qui retourne un objet, l'objet retourné est utilisé en tant qu'état racine. Ceci est utile quand vous voulez réutiliser un objet d'état surtout dans un cas de réutilisation de module. [Plus de détails](../guide/modules.md#réutiliser-un-module)
+
+### mutations
+
+  - type : `{ [type: string]: Function }`
+
+    Enregistrer les mutations sur le store. La fonction gestionnaire reçoit toujours `state` comme premier argument (sera l'état local du module si défini dans un module), et reçoit le `payload` en second argument s'il y en a un.
+
+    [Plus de détails](../guide/mutations.md)
+
+### actions
+
+  - type : `{ [type: string]: Function }`
+
+    Enregistrer les actions sur le store. La fonction gestionnaire reçoit un objet `context` qui expose les propriétés suivantes :
+
+    ``` js
+    {
+      state,      // identique à `store.state`, ou à l'état local si dans des modules
+      rootState,  // identique à `store.state`, seulement dans des modules
+      commit,     // identique à `store.commit`
+      dispatch,   // identique à `store.dispatch`
+      getters,    // identique à `store.getters`, ou les accesseurs locaux dans les modules
+      rootGetters // identique à `store.getters`, seulement dans les modules
+    }
+    ```
+
+    [Plus de détails](../guide/actions.md)
+
+### getters
+
+  - type : `{ [key: string]: Function }`
+
+    Enregistrer les accesseurs sur le store. La fonction accesseur reçoit les arguments suivants :
+
+    ```
+    state,    // sera l'état local du module si défini dans un module.
+    getters   // identique à `store.getters`
+    ```
+
+    Arguments spécifiques quand défini dans un module
+
+    ```
+    state,       // sera l'état local du module si défini dans un module.
+    getters,     // module local getters of the current module
+    rootState,   // état global
+    rootGetters  // tous les accesseurs
+    ```
+
+    Les accesseurs enregistrés sont exposés sur `store.getters`.
+
+    [Plus de détails](../guide/getters.md)
+
+### modules
+
+  - type : `Object`
+
+    Un objet contenant des sous-modules qui seront regroupés dans le store, sous la forme suivante :
+
+    ``` js
+    {
+      key: {
+        state,
+        namespaced?,
+        mutations?,
+        actions?,
+        getters?,
+        modules?
+      },
+      ...
+    }
+    ```
+
+    Chaque module peut contenir `state` et `mutations`, tout comme les options racines. L'état d'un module sera attaché à l'état racine du store en utilisant la clé du module. Les mutations et accesseurs d'un module recevront seulement l'état local du module en premier argument au lieu de l'état racine, et le `context.state` des actions du module pointeront également vers l'état local.
+
+    [Plus de détails](../guide/modules.md)
+
+### plugins
+
+  - type : `Array<Function>`
+
+    Un tableau de fonctions plugins qui seront appliquées au store. Un plugin reçoit simplement le store comme seul argument et peut soit écouter les mutations (pour la persistance de données, les logs ou le débogage) ou propager des mutations (pour les données internes, c.-à-d. websockets ou observables).
+
+    [Plus de détails](../guide/plugins.md)
+
+### strict
+
+  - type : `Boolean`
+  - default: `false`
+
+    Force le store Vuex en mode strict. En mode strict, toute mutation de l'état en dehors des gestionnaires de mutation lancera une erreur.
+
+    [Plus de détails](../guide/strict.md)
+
+## Propriétés d'instance de `Vuex.Store`
+
+### state
+
+  - type : `Object`
+
+    L'état racine. Lecture seule.
+
+### getters
+
+  - type : `Object`
+
+    Expose les accesseurs enregistrés. Lecture seule.
+
+## Méthodes d'instance de `Vuex.Store`
+
+### commit
+
+-  `commit(type: string, payload?: any, options?: Object)`
+-  `commit(mutation: Object, options?: Object)`
+
+  Acter une mutation. `options` peut avoir `root: true` ce qui permet d'acter des mutations racines dans des [modules sous espace de nom](../guide/modules.md#namespacing). [Plus de détails](../guide/mutations.md)
+
+### dispatch
+
+-  `dispatch(type: string, payload?: any, options?: Object)`
+-  `dispatch(action: Object, options?: Object)`
+
+  Propager une action. Retourne la valeur renvoyée par le gestionnaire d'action déclenché, ou une Promesse si plusieurs gestionnaires ont été déclenchés. [Plus de détails](../guide/actions.md)
+
+### replaceState
+
+-  `replaceState(state: Object)`
+
+  Remplacer l'état racine du store. Utiliser seulement pour hydrater l'état ou dans le but de voyager dans le temps.
+
+### watch
+
+-  `watch(getter: Function, cb: Function, options?: Object)`
+
+  Observer de façon réactive la valeur de retour d'une fonction accesseur, et appeler la fonction de rappel lorsque la valeur change. L'accesseur reçoit l'état du store en premier argument, et les accesseurs en second argument. Accepte un objet optionnel d'options qui prend les mêmes options que la méthode `vm.$watch` de Vue.
+
+  Pour arrêter d'observer, appeler la fonction gestionnaire retournée.
+
+### subscribe
+
+-  `subscribe(handler: Function)`
+
+  S'abonner aux mutations du store. Le `handler` est appelé après chaque mutation et reçoit le descripteur de mutation et l'état post mutation comme arguments :
+
+  ``` js
+  store.subscribe((mutation, state) => {
+    console.log(mutation.type)
+    console.log(mutation.payload)
+  })
+  ```
+
+  Utilisé plus communément dans les plugins. [Plus de détails](../guide/plugins.md)
+
+### subscribeAction
+
+-  `subscribeAction(handler: Function)`
+
+  > Nouveau dans la 2.5.0+
+
+  S'abonner au actions du store. Le `handler` est appelé pour chaque action propagée et reçoit chaque description d'action et l'état du store courant en arguments :
+
+  ``` js
+  store.subscribeAction((action, state) => {
+    console.log(action.type)
+    console.log(action.payload)
+  })
+  ```
+
+  Souvent utiliser dans les plugins. [Pour plus de détails](../guide/plugins.md)
+
+### registerModule
+
+-  `registerModule(path: string | Array<string>, module: Module, options?: Object)`
+
+  Enregistrer un module dynamique. [Plus de détails](../guide/modules.md#enregistrement-dynamique-de-module)
+
+  `options` peut avoir `preserveState: true` qui lui permet de préserver l'état précédent. Utile pour du rendu côté serveur.
+
+### unregisterModule
+
+-  `unregisterModule(path: string | Array<string>)`
+
+  Supprimer un module dynamique. [Plus de détails](../guide/modules.md#enregistrement-dynamique-de-module)
+
+### hotUpdate
+
+-  `hotUpdate(newOptions: Object)`
+
+  Remplacement à la volée des nouvelles actions et mutations. [Plus de détails](../guide/hot-reload.md)
+
+## Fonctions utilitaires d'attachement au composant
+
+### mapState
+
+-  `mapState(namespace?: string, map: Array<string> | Object): Object`
+
+  Créer des propriétés calculées qui retournent le sous-arbre du store Vuex au composant. [Plus de détails](../guide/state.md#le-helper-mapstate)
+
+  Le premier argument peut être de façon optionnelle une chaine d'espace de nom. [Plus de détails](../guide/modules.md#Fonctions-utilitaires-liées-avec-espace-de-nom)
+
+### mapGetters
+
+-  `mapGetters(namespace?: string, map: Array<string> | Object): Object`
+
+  Créer des propriétés calculées qui retournent la valeur calculée d'un accesseur. [Plus de détails](../guide/getters.md#la-function-utilitaire-mapgetters)
+
+  Le premier argument peut être de façon optionnelle une chaine d'espace de nom. [Plus de détails](../guide/modules.md#Fonctions-utilitaires-liées-avec-espace-de-nom)
+
+### mapActions
+
+-  `mapActions(namespace?: string, map: Array<string> | Object): Object`
+
+  Créer des méthodes de composant qui propagent une action. [Plus de détails](../guide/actions.md#propager-des-actions-dans-les-composants)
+
+  Le premier argument peut être de façon optionnelle une chaine d'espace de nom. [Plus de détails](../guide/modules.md#Fonctions-utilitaires-liées-avec-espace-de-nom)
+
+### mapMutations
+
+-  `mapMutations(namespace?: string, map: Array<string> | Object): Object`
+
+  Créer des méthodes de composant qui actent une mutation. [Plus de détails](../guide/mutations.md#acter-des-mutations-dans-les-composants)
+
+  Le premier argument peut être de façon optionnelle une chaine d'espace de nom. [Plus de détails](../guide/modules.md#Fonctions-utilitaires-liées-avec-espace-de-nom)
+
+### createNamespacedHelpers
+
+-  `createNamespacedHelpers(namespace: string): Object`
+
+  Créer des fonctions utilitaires liées avec espace de nom. L'objet retourné contient `mapState`, `mapGetters`, `mapActions` et `mapMutations` qui sont liées à l'espace de nom fourni. [Plus de détails](../guide/modules.md#fonctions-utilitaires-liées-avec-espace-de-nom)