Added Italian Translation (#117)

* Added Italian Translation

* Fixed link

* Translated State documentation

* Translated state

* Translated Mutations

* Improved translation

* Finished Action translation

* Finished Data Flow translation

* Translated structure

* Fixed wrong link

* Translated middlewares

* Improved translation

* Translated strict

* Translated forms

* Translated Hot Reload

* Translated API

* Started last translation

* Translate Testing. The translation is complete

Author: ludo237

docs/en/middlewares.md

@@ -48,7 +48,7 @@ const store = new Vuex.Store({
 })
 ```
 
-The middleware will be used by default. For production, use the build setup described [here](http://vuejs.org/guide/application.html#Deploying_for_Production) to convert the value of `process.env.NODE_ENV !== 'production'` to `false` for the final build.
+The middleware will be used by default. For production, use the build setup described [here](http://vuejs.org/guide/application.html#Deploying-for-Production) to convert the value of `process.env.NODE_ENV !== 'production'` to `false` for the final build.
 
 ### Built-in Logger Middleware
 

docs/it/README.md

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

docs/it/SUMMARY.md

@@ -0,0 +1,18 @@
+# Tabella dei Contenuti
+
+> Raccomandiamo di leggere il tutto secondo l'ordine stabilito.
+
+- [Che cosa è Vuex?](intro.md)
+- [Per iniziare](getting-started.md)
+- Concetti fondamentali
+  - [Stato e Getter](state.md)
+  - [Mutation](mutations.md)
+  - [Action](actions.md)
+- [Flusso dei Dati](data-flow.md)
+- [Struttura dell'Applicazione](structure.md)
+- [Middleware](middlewares.md)
+- [Modalità Strict](strict.md)
+- [Gestione dei Form](forms.md)
+- [Test del Codice](testing.md)
+- [Aggiornamento Automatico](hot-reload.md)
+- [Documentazione delle API](api.md)

docs/it/actions.md

@@ -0,0 +1,133 @@
+# Actions
+
+> Le azioni, action, in Vuex sono i cosidetti "Actions creator" nel mondo di Flux. Ma questo termine è fuorviante.
+
+Le action sono semplici funzioni che inviano le mutation. Per convenzione, le action in Vuex si aspettano sempre un istanza di store come primo argomento, seguito da altri argomenti opzionali:
+
+``` js
+// l'action più semplice
+function increment (store) {
+  store.dispatch('INCREMENT')
+}
+
+// una semplice azione con più argomenti
+// che sfrutta il distruttore dei ES2015
+function incrementBy ({ dispatch }, amount) {
+  dispatch('INCREMENT', amount)
+}
+```
+
+La domanda può sorgere spontanea, perchè non inviamo direttamente le mutation senza passare per le azioni? Ricordate che **le mutation sono sempre sincrone**? Bene, tramite le action noi possiamo scavalcare questo problema in quanto, internamente ad una action, possiamo gestire codice asincrono!
+
+``` js
+function incrementAsync ({ dispatch }) {
+  setTimeout(() => {
+    dispatch('INCREMENT')
+  }, 1000)
+}
+```
+
+Un esempio pratico può essere il sistema di checkout di un carrello che richiede **chiamate asincrone ad API** e **l'invio di mutation multiple**:
+
+``` js
+function checkout ({ dispatch, state }, products) {
+  // salviamo l'oggetto corrente
+  const savedCartItems = [...state.cart.added]
+  // inviamo una richiesta di checkout
+  dispatch(types.CHECKOUT_REQUEST)
+  // in questo caso le API accettano due callback per success e failure
+  shop.buyProducts(
+    products,
+    // success
+    () => dispatch(types.CHECKOUT_SUCCESS),
+    // failure
+    () => dispatch(types.CHECKOUT_FAILURE, savedCartItems)
+  )
+}
+```
+
+Si noti che invece di aspettarsi un valore di ritorno, la gestione delle API asincrone è fatta chiamando altre mutation. Possiamo quindi definire una regola di base dove **l'unico effetto prodotto dalla chiamata ad azioni è l'invio di mutation**.
+
+### Chiamare gli Action nei Componenti
+
+Forse avrete notato che le azioni, e le funzioni legate ad esse, non possono essere chiamate direttamente senza una referenza all'istanza dello store. Tecnicamente si potrebbe fare chiamando `action(this.$store)` internamente ad un metodo, è comunque consigliato esporre un set di API dal componente tramite `vuex.actions`, per esempio:
+
+``` js
+// internamente ad un componente
+import { incrementBy } from './actions'
+
+const vm = new Vue({
+  vuex: {
+    getters: { ... }, // i getter
+    actions: {
+      incrementBy // Utilizziamo la sintassi ES6 per gli oggetti
+    }
+  }
+})
+```
+
+Il codice appena visto lega l'azione `incrementBy` con l'istanza di uguale nome nello store ed espone tale istanza al componente tramite `vm.incrementBy`. Tutti gli argomenti passati ad `vm.incrementBy` saranno passai prima all'azione e poi allo store in questo modo:
+
+``` js
+vm.incrementBy(1)
+```
+
+è uguale a scrivere:
+
+``` js
+incrementBy(vm.$store, 1)
+```
+
+ma il beneficio di avere tale sintassi è che ora possiamo usare:
+
+``` html
+<button v-on:click="incrementBy(1)">Incrementa di uno</button>
+```
+
+Ovviamente potete utilizzare un altro nome dentro il componente, l'importante è referenziarlo all'istanza nello store:
+
+``` js
+// il componente
+import { incrementBy } from './actions'
+
+const vm = new Vue({
+  vuex: {
+    getters: { ... },
+    actions: {
+      plus: incrementBy // usiamo un altro nome
+    }
+  }
+})
+```
+
+Ora l'action sarà legata a `vm.plus` invece che `vm.incrementBy`.
+
+### Action Inline
+
+Se un'azione è specifica per un determinato componente, allora possiamo usare una scorciatoia e definirla inline:
+
+``` js
+const vm = new Vue({
+  vuex: {
+    getters: { ... },
+    actions: {
+      plus: ({ dispatch }) => dispatch('INCREMENT')
+    }
+  }
+})
+```
+
+### Legare tutte le Action
+
+Possiamo vincolare un componente ad avere tutte le action senza specificarne nessuna:
+
+``` js
+import * as actions from './actions'
+
+const vm = new Vue({
+  vuex: {
+    getters: { ... },
+    actions // il componente ora accede a tutte le action
+  }
+})
+```

docs/it/api.md

@@ -0,0 +1,94 @@
+# Referenza alle API
+
+### Vuex.Store
+
+``` js
+import Vuex from 'vuex'
+
+const store = new Vuex.Store({ ...opzioni })
+```
+
+### Opzioni per il Costruttore
+
+- **state**
+
+  - tipo: `Oggetto`
+
+    Lo stato principale per lo store di Vuex.
+
+    [Dettagli](state.md)
+
+- **mutations**
+
+  - tipo: `Oggetto`
+
+    Un Oggetto che ha come chiavi i nomi delle mutation e come valore il nome della funzione (handler) della mutation stessa. L'handler ricevere sempre `state` come primo argomento.
+
+    [Dettagli](mutations.md)
+
+- **modules**
+
+  - tipo: `Oggetto`
+
+    Un  Oggetto contenente tutti i sub moduli che si uniranno allo store, di solito è formato tipo:
+
+    ``` js
+    {
+      key: {
+        state,
+        mutations
+      },
+      ...
+    }
+    ```
+
+    Ogni modulo può contenere uno stato `state` e delle `mutations`, molto simile al'opzione di root. Lo stato di un modulo sarà legato a quello principale dello store e sarà accessibile tramite il nome del modulo. Una mutation in un modulo riceverà solo lo stato del modulo stesso invece di quello principale (root state).
+
+- **middlewares**
+
+  - tipo: `Array<Oggetto>`
+
+    Un oggetto che contiene tutti i middleware del tipo:
+
+    ``` js
+    {
+      snapshot: Boolean, // predefinito: false
+      onInit: Funzione,
+      onMutation: Funzione
+    }
+    ```
+
+    Tutti i campi sono facoltativi. [Dettagli](middlewares.md)
+
+- **strict**
+
+  - tipo: `Boolean`
+  - predefinito: `false`
+
+    Forza Vuex ad avere lo store in modalità strict. In questa modalità tutte le mutazioni al di fuori del sistema di mutation di Vuex solleveranno un Errore.
+
+    [Dettagli](strict.md)
+
+### Proprietà di istanza di Vuex.Store
+
+- **state**
+
+  - tipo: `Oggetto`
+
+    Lo stato principale. In sola lettura.
+
+### Metodi di istanza di Vuex.Store
+
+- **dispatch(nomeMutazione: Stringa, ...argomenti)**
+
+  Directly dispatch a mutation. This is useful in certain situations are in general you should prefer using actions in application code.
+
+- **watch(pathOrGetter: Stringa|Funzione, cb: Funzione, [opzioni: Oggetto])**
+
+  Watch a path or a getter Funzione's value, and call the callback when the value changes. Accepts an optional opzioni Oggetto that takes the same opzioni as Vue's `vm.$watch` method.
+
+  To stop watching, call the returned handle Funzione.
+
+- **hotUpdate(opzioni: Oggetto)**
+
+  Hot swap new actions and mutations. [Dettagli](hot-reload.md)

docs/it/book.json

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

docs/it/data-flow.md

@@ -0,0 +1,89 @@
+# Flusso dei Dati
+
+Costruiamo un semplice contatore tramite Vuex per avere una visione migliore su come i dati siano scambiati tra i vari componenti. Si noti che questo esempio è un estremizzazione per spiegare alcuni concetti chiavi, Vuex non è utile per questo tipo di applicazioni molto semplici.
+
+### Lo Store
+
+``` js
+// store.js
+import Vue from 'vue'
+import Vuex from 'vuex'
+
+Vue.use(Vuex)
+
+// Stato iniziale della nostra applicazione
+const state = {
+  count: 0
+}
+
+// Definiamo tutte le mutazioni
+const mutations = {
+  INCREMENT (state) {
+    state.count++
+  },
+  DECREMENT (state) {
+    state.count--
+  }
+}
+
+// creiamo lo store
+export default new Vuex.Store({
+  state,
+  mutations
+})
+```
+
+### Action
+
+``` js
+// actions.js
+export const increment = ({ dispatch }) => dispatch('INCREMENT')
+export const decrement = ({ dispatch }) => dispatch('DECREMENT')
+```
+
+### Utilizziamo Vue
+
+**Il Template**
+
+``` html
+<div id="app">
+  Hai Cliccato: {{ count }} volte
+  <button v-on:click="increment">+</button>
+  <button v-on:click="decrement">-</button>
+</div>
+```
+
+**Lo Script**
+
+``` js
+// Stiamo importanto ed iniettando lo store perchè questo è il componente di root
+// In un'applicazione grossa questo procedimento viene fatto una sola volta
+import store from './store'
+import { increment, decrement } from './actions'
+
+const app = new Vue({
+  el: '#app',
+  store,
+  vuex: {
+    getters: {
+      count: state => state.count
+    },
+    actions: {
+      increment,
+      decrement
+    }
+  }
+})
+```
+
+Ecco fatto, questa applicazione è molto semplice e mostra come le action, mutazioni e lo store funzionino in modo tale da manipolare, anche se in questo caso molto banalmente, lo stato in base agli eventi che arrivano dal template, o utente.
+
+Noterete anche che il flusso dei dati è unidirezionale, come dovrebbe esserlo in Flux:
+
+1. L'utente sfrutta un componente per eseguire delle action;
+2. Le action avvitano le mutazioni che cambiano lo stato;
+3. Una volta che lo stato cambia una proprietà dello store, tale cambiamento viene riflesso ai componenti tramite i getter.
+
+<p align="center">
+  <img width="700px" src="vuex.png">
+</p>

docs/it/forms.md

@@ -0,0 +1,41 @@
+# Gestione dei Form
+
+Quando si utilizza Vuex in modalità strict, può risultare difficile utilizzare `v-model` su uno stato che appartiene a Vuex:
+
+``` html
+<input v-model="obj.message">
+```
+
+Presupponendo che `obj` sia una proprietà derivata che restituisce un oggetto dallo store, avremmo una situazione dove `v-model` cerca di mutare direttamente `obj.message` quando l'utente modifica l'input. In modalità strict questo solleverebbe un errore a causa di una mutazione non avvenuta internamente ad una mutation di Vuex.
+
+Un modo per risolvere questo conflitto in Vuex è quello di legare l `<input>` ad una chiamata che si riferisce ad un'azione. L'input si lega tramite `input` oppure l'evento `change`:
+
+``` html
+<input :value="message" @input="updateMessage">
+```
+``` js
+// ...
+vuex: {
+  getters: {
+    message: state => state.obj.message
+  },
+  actions: {
+    updateMessage: ({ dispatch }, e) => {
+      dispatch('UPDATE_MESSAGE', e.target.value)
+    }
+  }
+}
+```
+
+E ora scriviamo la mutation:
+
+``` js
+// ...
+mutations: {
+  UPDATE_MESSAGE (state, message) {
+    state.obj.message = message
+  }
+}
+```
+
+Questo approccio rendere l'utilizzo di `v-model` leggermente più complesso ma è un trade-off necessario per rendere il vincolo tra l'input e lo stato tracciabile. Detto questo è giusto ricordare che Vuex non obbliga l'inserimento di tutti gli stati dentro ad uno store, se avete bisogno di tracciare degli stati che sono specifici di un solo componente è possibile farlo benissimo fuori dallo store di Vuex.