rename: dispatch -> commit, trigger -> dispatch

examples/chat/components/MessageSection.vue

@@ -42,7 +42,7 @@ export default {
     sendMessage (e) {
       const text = e.target.value
       if (text.trim()) {
-        this.$store.trigger('sendMessage', {
+        this.$store.dispatch('sendMessage', {
           text,
           thread: this.thread
         })

examples/chat/components/ThreadSection.vue

@@ -40,7 +40,7 @@ export default {
   },
   methods: {
     switchThread (id) {
-      this.$store.trigger('switchThread', { id })
+      this.$store.dispatch('switchThread', { id })
     }
   }
 }

examples/chat/vuex/actions.js

@@ -1,22 +1,22 @@
 import * as api from '../api'
 import * as types from './mutation-types'
 
-export const getAllMessages = ({ dispatch }) => {
+export const getAllMessages = ({ commit }) => {
   api.getAllMessages(messages => {
-    dispatch(types.RECEIVE_ALL, {
+    commit(types.RECEIVE_ALL, {
       messages
     })
   })
 }
 
-export const sendMessage = ({ dispatch }, payload) => {
+export const sendMessage = ({ commit }, payload) => {
   api.createMessage(payload, message => {
-    dispatch(types.RECEIVE_MESSAGE, {
+    commit(types.RECEIVE_MESSAGE, {
       message
     })
   })
 }
 
-export const switchThread = ({ dispatch }, payload) => {
-  dispatch(types.SWITCH_THREAD, payload)
+export const switchThread = ({ commit }, payload) => {
+  commit(types.SWITCH_THREAD, payload)
 }

examples/counter-hot/vuex/actions.js

@@ -1,14 +1,14 @@
-export const increment = ({ dispatch }) => dispatch('increment')
-export const decrement = ({ dispatch }) => dispatch('decrement')
+export const increment = ({ commit }) => commit('increment')
+export const decrement = ({ commit }) => commit('decrement')
 
-export const incrementIfOdd = ({ dispatch, state }) => {
+export const incrementIfOdd = ({ commit, state }) => {
   if ((state.count + 1) % 2 === 0) {
-    dispatch('increment')
+    commit('increment')
   }
 }
 
-export const incrementAsync = ({ dispatch }) => {
+export const incrementAsync = ({ commit }) => {
   setTimeout(() => {
-    dispatch('decrement')
+    commit('decrement')
   }, 1000)
 }

examples/counter/store.js

@@ -26,17 +26,17 @@ const mutations = {
 // actions are functions that causes side effects and can involve
 // asynchronous operations.
 const actions = {
-  increment: ({ dispatch }) => dispatch('increment'),
-  decrement: ({ dispatch }) => dispatch('decrement'),
-  incrementIfOdd ({ dispatch, state }) {
+  increment: ({ commit }) => commit('increment'),
+  decrement: ({ commit }) => commit('decrement'),
+  incrementIfOdd ({ commit, state }) {
     if ((state.count + 1) % 2 === 0) {
-      dispatch('increment')
+      commit('increment')
     }
   },
-  incrementAsync ({ dispatch }) {
+  incrementAsync ({ commit }) {
     return new Promise((resolve, reject) => {
       setTimeout(() => {
-        dispatch('increment')
+        commit('increment')
         resolve()
       }, 1000)
     })

examples/shopping-cart/components/Cart.vue

@@ -30,7 +30,7 @@ export default {
   },
   methods: {
     checkout (products) {
-      this.$store.trigger('checkout', products)
+      this.$store.dispatch('checkout', products)
     }
   }
 }

examples/shopping-cart/components/ProductList.vue

@@ -23,7 +23,7 @@ export default {
     'addToCart'
   ]),
   created () {
-    this.$store.trigger('getAllProducts')
+    this.$store.dispatch('getAllProducts')
   }
 }
 </script>

examples/shopping-cart/vuex/actions.js

@@ -1,26 +1,26 @@
 import shop from '../api/shop'
 import * as types from './mutation-types'
 
-export const addToCart = ({ dispatch }, product) => {
+export const addToCart = ({ commit }, product) => {
   if (product.inventory > 0) {
-    dispatch(types.ADD_TO_CART, {
+    commit(types.ADD_TO_CART, {
       id: product.id
     })
   }
 }
 
-export const checkout = ({ dispatch, state }, products) => {
+export const checkout = ({ commit, state }, products) => {
   const savedCartItems = [...state.cart.added]
-  dispatch(types.CHECKOUT_REQUEST)
+  commit(types.CHECKOUT_REQUEST)
   shop.buyProducts(
     products,
-    () => dispatch(types.CHECKOUT_SUCCESS),
-    () => dispatch(types.CHECKOUT_FAILURE, { savedCartItems })
+    () => commit(types.CHECKOUT_SUCCESS),
+    () => commit(types.CHECKOUT_FAILURE, { savedCartItems })
   )
 }
 
-export const getAllProducts = ({ dispatch }) => {
+export const getAllProducts = ({ commit }) => {
   shop.getProducts(products => {
-    dispatch(types.RECEIVE_PRODUCTS, { products })
+    commit(types.RECEIVE_PRODUCTS, { products })
   })
 }

examples/todomvc/components/App.vue

@@ -81,7 +81,7 @@ export default {
     addTodo (e) {
       var text = e.target.value
       if (text.trim()) {
-        this.$store.trigger('addTodo', { text })
+        this.$store.dispatch('addTodo', { text })
       }
       e.target.value = ''
     },

examples/todomvc/vuex/actions.js

@@ -6,5 +6,5 @@ export const toggleAll = makeAction('TOGGLE_ALL')
 export const clearCompleted = makeAction('CLEAR_COMPLETED')
 
 function makeAction (type) {
-  return ({ dispatch }, payload) => dispatch(type, payload)
+  return ({ commit }, payload) => commit(type, payload)
 }

src/helpers.js

@@ -12,7 +12,7 @@ export function mapActions (actions) {
   const res = {}
   normalizeMap(actions).forEach(({ key, val }) => {
     res[key] = function mappedAction (...args) {
-      return this.$store.trigger(val, ...args)
+      return this.$store.dispatch(val, ...args)
     }
   })
   return res

src/index.js

@@ -27,21 +27,21 @@ class Store {
 
     // store internal state
     this._options = options
-    this._dispatching = false
+    this._committing = false
     this._events = Object.create(null)
     this._actions = Object.create(null)
     this._mutations = Object.create(null)
     this._subscribers = []
 
-    // bind dispatch and trigger to self
+    // bind commit and dispatch to self
     const store = this
-    const { trigger, dispatch } = this
-    this.trigger = function boundTrigger (type, payload) {
-      trigger.call(store, type, payload)
-    }
+    const { dispatch, commit } = this
     this.dispatch = function boundDispatch (type, payload) {
       dispatch.call(store, type, payload)
     }
+    this.commit = function boundCommit (type, payload) {
+      commit.call(store, type, payload)
+    }
 
     // init state and getters
     const getters = extractModuleGetters(options.getters, modules)
@@ -66,9 +66,9 @@ class Store {
   }
 
   replaceState (state) {
-    this._dispatching = true
+    this._committing = true
     this._vm.state = state
-    this._dispatching = false
+    this._committing = false
   }
 
   module (path, module, hot) {
@@ -123,57 +123,54 @@ class Store {
   action (type, handler, path = []) {
     const entry = this._actions[type] || (this._actions[type] = [])
     const store = this
-    const { trigger, dispatch } = this
+    const { dispatch, commit } = this
     entry.push(function wrappedActionHandler (payload, cb) {
       let res = handler({
-        trigger,
         dispatch,
+        commit,
         state: getNestedState(store.state, path)
       }, payload, cb)
       if (!isPromise(res)) {
         res = Promise.resolve(res)
       }
       return res.catch(err => {
-        console.warn(`[vuex] error in Promise returned from action "${type}":`)
+        console.error(`[vuex] error in Promise returned from action "${type}":`)
         console.error(err)
       })
     })
   }
 
-  dispatch (type, payload) {
+  commit (type, payload) {
     const entry = this._mutations[type]
     if (!entry) {
-      console.warn(`[vuex] unknown mutation type: ${type}`)
+      console.error(`[vuex] unknown mutation type: ${type}`)
       return
     }
-    // check object-style dispatch
+    // check object-style commit
     let mutation
     if (isObject(type)) {
       payload = mutation = type
     } else {
       mutation = { type, payload }
     }
-    this._dispatching = true
-    entry.forEach(function dispatchIterator (handler) {
+    this._committing = true
+    entry.forEach(function commitIterator (handler) {
       handler(payload)
     })
-    this._dispatching = false
+    this._committing = false
     this._subscribers.forEach(sub => sub(mutation, this.state))
   }
 
-  trigger (type, payload, cb) {
+  dispatch (type, payload) {
     const entry = this._actions[type]
     if (!entry) {
-      console.warn(`[vuex] unknown action type: ${type}`)
+      debugger
+      console.error(`[vuex] unknown action type: ${type}`)
       return
     }
-    if (typeof payload === 'function') {
-      cb = payload
-      payload = undefined
-    }
     return entry.length > 1
       ? Promise.all(entry.map(handler => handler(payload)))
-      : entry[0](payload)
+      : Promise.resolve(entry[0](payload))
   }
 
   subscribe (fn) {
@@ -214,11 +211,11 @@ class Store {
       if (this.strict) {
         enableStrictMode(this)
       }
-      // trigger changes in all subscribed watchers
+      // dispatch changes in all subscribed watchers
       // to force getter re-evaluation.
-      this._dispatching = true
+      this._committing = true
       oldVm.state = null
-      this._dispatching = false
+      this._committing = false
       Vue.nextTick(() => oldVm.$destroy())
     }
   }
@@ -257,7 +254,7 @@ function extractModuleGetters (getters = {}, modules = {}, path = []) {
       Object.keys(module.getters).forEach(getterKey => {
         const rawGetter = module.getters[getterKey]
         if (getters[getterKey]) {
-          console.warn(`[vuex] duplicate getter key: ${getterKey}`)
+          console.error(`[vuex] duplicate getter key: ${getterKey}`)
           return
         }
         getters[getterKey] = function wrappedGetter (state) {
@@ -272,7 +269,7 @@ function extractModuleGetters (getters = {}, modules = {}, path = []) {
 
 function enableStrictMode (store) {
   store._vm.$watch('state', () => {
-    if (!store._dispatching) {
+    if (!store._committing) {
       throw new Error(
         '[vuex] Do not mutate vuex store state outside mutation handlers.'
       )
@@ -294,7 +291,7 @@ function getNestedState (state, path) {
 
 function install (_Vue) {
   if (Vue) {
-    console.warn(
+    console.error(
       '[vuex] already installed. Vue.use(Vuex) should be called only once.'
     )
     return