Translated docs in French 🇫🇷

docs/LANGS.md

@@ -1,2 +1,3 @@
 * [2.0 - English](en/)
+* [2.0 - Français](fr/)
 * [1.0 Docs](old/)

docs/fr/README.md

@@ -0,0 +1 @@
+SUMMARY.md

docs/fr/SUMMARY.md

@@ -0,0 +1,22 @@
+# Vuex
+
+> Note : Ceci est la documentation pour vuex@2.x.
+
+- [Vous cherchez la documentation de la v1.0 ?](https://github.com/vuejs/vuex/tree/1.0/docs)
+- [Release Notes](https://github.com/vuejs/vuex/releases)
+- [Installation](installation.md)
+- [Qu'est-ce que Vuex ?](intro.md)
+- [Débuter](getting-started.md)
+- Concepts de base
+  - [State](state.md)
+  - [Getters](getters.md)
+  - [Mutations](mutations.md)
+  - [Actions](actions.md)
+  - [Modules](modules.md)
+- [Structure d'une application](structure.md)
+- [Plugins](plugins.md)
+- [Strict Mode](strict.md)
+- [Formulaires](forms.md)
+- [Tests](testing.md)
+- [Hot Reloading](hot-reload.md)
+- [Documentation API](api.md)

docs/fr/actions.md

@@ -0,0 +1,174 @@
+# Actions
+
+Les actions sont similaires aux mutations, à la différence que :
+
+- Au lieu de modifier le state, les actions committent des mutations.
+- Les actions peuvent contenir des opérations asynchrones.
+
+Enregistrons une simple action :
+
+``` js
+const store = new Vuex.Store({
+  state: {
+    count: 0
+  },
+  mutations: {
+    increment (state) {
+      state.count++
+    }
+  },
+  actions: {
+    increment (context) {
+      context.commit('increment')
+    }
+  }
+})
+```
+
+Les handlers d'action reçoivent un objet contexte qui expose le même set de méthodes/propriétés que l'instance du store, donc vous pouvez appeler `context.commit` pour commiter une mutation, ou accéder au state et aux getters via `context.state` et `context.getters`. Nous verrons pourquoi cet objet contexte n'est pas l'instance du store elle-même lorsque nous présenterons les [Modules](moduels.md) plus tard.
+
+En pratique, nous utilisons souvent la [destructuration d'argument](https://github.com/lukehoban/es6features#destructuring) (*argument destructuring*) pour simplifier quelque peu le code (particulièrement si nous avons besoin d'appeler `commit` plusieurs fois) :
+
+``` js
+actions: {
+  increment ({ commit }) {
+    commit('increment')
+  }
+}
+```
+
+### Dispatcher des actions dans les composants
+
+Les actions sont déclenchées par la méthode `store.dispatch` :
+
+``` js
+store.dispatch('increment')
+```
+
+Cela peut sembler idiot au premier abord : si nous avons besoin d'incrémenter le compteur, pourquoi ne pas simplement appeler `store.commit('increment')` directement ? Et bien, vous rappelez-vous que **les mutations doivent être synchrones** ? Les actions ne suivent pas cette règle. Il est possible de procéder à des opérations **asynchrones** dans une action :
+
+``` js
+actions: {
+  incrementAsync ({ commit }) {
+    setTimeout(() => {
+      commit('increment')
+    }, 1000)
+  }
+}
+```
+
+Les actions prennent en charge le même format de payload et *object-style dispatch* :
+
+``` js
+// dispatcher avec un payload
+store.dispatch('incrementAsync', {
+  amount: 10
+})
+
+// dispatcher avec un object
+store.dispatch({
+  type: 'incrementAsync',
+  amount: 10
+})
+```
+
+Un exemple plus pratique d'une application du monde réel serait une action pour check-out un panier d'achats, ce qui implique **d'appeler une API asynchrone** et de **comitter de multiples mutations** :
+
+``` js
+actions: {
+  checkout ({ commit, state }, payload) {
+    // sauvegarder les articles actuellement dans le panier
+    const savedCartItems = [...state.cart.added]
+    // envoyer la requête de checkout, et vider le panier
+    commit(types.CHECKOUT_REQUEST)
+    // l'API du shop prend un callback success et un callback failure
+    shop.buyProducts(
+      products,
+      // handle success
+      () => commit(types.CHECKOUT_SUCCESS),
+      // handle failure
+      () => commit(types.CHECKOUT_FAILURE, savedCartItems)
+    )
+  }
+}
+```
+
+Notez que nous procédons à un flux d'opérations asynchrones, et enregistrons les effets de bord (mutation du state) de l'action en les committant.
+
+### Dispatcher des actions dans les composants
+
+Vous pouvez dispatcher des actions dans les composants avec `this.$store.dispatch('xxx')`, ou en utilisant le helper `mapActions` qui attache les méthodes du composant aux appels de `store.dispatch` (nécessite l'injection de `store` à la racine) :
+
+``` js
+import { mapActions } from 'vuex'
+
+export default {
+  // ...
+  methods: {
+    ...mapActions([
+      'increment' // attacher this.increment() à this.$store.dispatch('increment')
+    ]),
+    ...mapActions({
+      add: 'increment' // attacher this.add() à this.$store.dispatch('increment')
+    })
+  }
+}
+```
+
+### Composer les actions
+
+Les actions sont souvent asynchrones, donc comment savoir lorsqu'une action est terminée ? Et plus important, comment composer plusieurs actions ensemble pour manipuler des flux asynchrones plus complexes ?
+
+La première chose à savoir est que `store.dispatch` retourne la valeur retournée par le handler de l'action déclenchée, vous pouvez donc retourner une Promise :
+
+``` js
+actions: {
+  actionA ({ commit }) {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        commit('someMutation')
+        resolve()
+      }, 1000)
+    })
+  }
+}
+```
+
+Maintenant vous pouvez faire :
+
+``` js
+store.dispatch('actionA').then(() => {
+  // ...
+})
+```
+
+Et également dans une autre action :
+
+``` js
+actions: {
+  // ...
+  actionB ({ dispatch, commit }) {
+    return dispatch('actionA').then(() => {
+      commit('someOtherMutation')
+    })
+  }
+}
+```
+
+Pour finir, nous pouvons utiliser de [async / await](https://tc39.github.io/ecmascript-asyncawait/), une fonctionnalité JavaScript qui sera disponible très bientôt, nous pouvons composer nos actions ainsi :
+
+``` js
+// sachant que getData() et getOtherData() retournent des Promises
+
+actions: {
+  async actionA ({ commit }) {
+    commit('gotData', await getData())
+  },
+  async actionB ({ dispatch, commit }) {
+    await dispatch('actionA') // wait for actionA to finish
+    commit('gotOtherData', await getOtherData())
+  }
+}
+```
+
+> Il est possible pour un `store.dispatch` de déclencher plusieurs handlers d'action dans différents modules. Dans ce genre de cas, la valeur retournée sera une Promise qui se résoud quand tous les handlers déclenchés ont été résolus.

docs/fr/api.md

@@ -0,0 +1,177 @@
+# Documentation API
+
+### Vuex.Store
+
+``` js
+import Vuex from 'vuex'
+
+const store = new Vuex.Store({ ...options })
+```
+
+### Options de constructeur de Vuex.Store
+
+- **state**
+
+  - type: `Object`
+
+    L'objet state racine pour le store Vuex.
+
+    [Détails](state.md)
+
+- **mutations**
+
+  - type: `{ [type: string]: Function }`
+
+    Enregistrer les mutations sur le store. La fonction handler reçoit toujours `state` comme premier argument (sera le state local du module si défini dans un module), et reçoit le `payload` en second argument s'il y en a un.
+
+    [Détails](mutations.md)
+
+- **actions**
+
+  - type: `{ [type: string]: Function }`
+
+    Enregistrer les actions sur le store. La fonction handler reçoit un objet `context` qui expose les propriétés suivantes :
+
+    ``` js
+    {
+      state,     // identique à store.state, ou au state 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
+    }
+    ```
+
+    [Détails](actions.md)
+
+- **getters**
+
+  - type: `{ [key: string]: Function }`
+
+    Enregistrer les getters sur le store. La fonction getter reçoit les arguments suivants :
+
+    ```
+    state,     // sera le state local du module si défini dans un module.
+    getters,   // indentique à store.getters
+    rootState  // indentique à store.state
+    ```
+    Les getters enregistrés sont exposés sur `store.getters`.
+
+    [Détails](getters.md)
+
+- **modules**
+
+  - type: `Object`
+
+    Un objet contenant des sous-modules qui seront regroupés dans le store, de la forme suivante :
+
+    ``` js
+    {
+      key: {
+        state,
+        mutations,
+        actions?,
+        getters?,
+        modules?
+      },
+      ...
+    }
+    ```
+
+    Chaque module peut contenir `state` et `mutations`, tout comme les options racine. Le state d'un module sera attaché au state racine du store en utilisant la clé du module. Les mutations et getters d'un module recevront seulement le state local du module en premier argument au lieu du state racine, et le `context.state` des actions du module pointeront également vers le state local.
+
+    [Détails](modules.md)
+
+- **plugins**
+
+  - type: `Array<Function>`
+
+    Un tableau de fonctions plugin qui seront appliqués au store. Un plugin reçoit simplement le store comme seul argument et peut soit écouter les mutations (pour la persistence de données, logging ou debugging) ou dispatcher des mutations (pour les données internes, i.e. websockets ou observables).
+
+    [Détails](plugins.md)
+
+- **strict**
+
+  - type: `Boolean`
+  - default: `false`
+
+    Force le store Vuex en mode strict. En mode strict, toute mutation du state en dehors des handlers de mutation lancera une Error.
+
+    [Détails](strict.md)
+
+### Propriétés d'instance de Vuex.Store
+
+- **state**
+
+  - type: `Object`
+
+    Le state racine. Lecture seule.
+
+- **getters**
+
+  - type: `Object`
+
+    Expose les getters enregistrés. Lecture seule.
+
+### Méthodes d'instance de Vuex.Store
+
+- **`commit(type: string, payload?: any) | commit(mutation: Object)`**
+
+  commiter une mutation. [Détails](mutations.md)
+
+- **`dispatch(type: string, payload?: any) | dispatch(action: Object)`**
+
+  Dispatcher une action. Retourne la valeur renvoyée par le handler d'action déclenché, ou une Promise si plusieurs handlers ont été déclenchés. [Détails](actions.md)
+
+- **`replaceState(state: Object)`**
+
+  Remplacer le state racine du store. Utiliser seulement pour hydrater le state ou voir le state dans le temps.
+
+- **`watch(getter: Function, cb: Function, options?: Object)`**
+
+  Observer de façon réactive la valeur de retour d'une fonction getter, et appeler le callback lorsque la valeur change. Le getter reçoit le state du store comme unique argument. Accepte un objet options optionnel qui prend les mêmes options que la méthode `vm.$watch` de Vue.
+
+  Pour arrêter d'observer, appeler la fonction retournée.
+
+- **`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 le state post-mutation comme arguments :
+
+  ``` js
+  store.subscribe((mutation, state) => {
+    console.log(mutation.type)
+    console.log(mutation.payload)
+  })
+  ```
+
+  Utilisé plus communément dans les plugins. [Détails](plugins.md)
+
+- **`registerModule(path: string | Array<string>, module: Module)`**
+
+  Enregistrer un module dynamique. [Détails](modules.md#enregistrement-dynamique-de-module)
+
+- **`unregisterModule(path: string | Array<string>)`**
+
+  Supprimer un module dynamique. [Détails](modules.md#enregistrement-dynamique-de-module)
+
+- **`hotUpdate(newOptions: Object)`**
+
+  Remplacement à la volée des nouvelles actions et mutations. [Détails](hot-reload.md)
+
+### Helpers d'attachement au composant
+
+- **`mapState(map: Array<string> | Object): Object`**
+
+  Créer des computed properties qui retournent le sub tree du store Vuex au composant. [Détails](state.md#le-helper-mapstate)
+
+- **`mapGetters(map: Array<string> | Object): Object`**
+
+  Créer des computed properties qui retournent la valeur calculée d'un getter. [Détails](getters.md#le-helper-mapgetters)
+
+- **`mapActions(map: Array<string> | Object): Object`**
+
+  Créer des méthodes de composant qui dispatchent une action. [Détails](actions.md#dispatcher-des-actions-dans-les-composants)
+
+- **`mapMutations(map: Array<string> | Object): Object`**
+
+  Créer des méthodes de composant qui committent une mutation. [Détails](mutations.md#commiter-des-mutations-dans-les-composants)

docs/fr/book.json

@@ -0,0 +1 @@
+../book.json