zerotwo/dist/zerotwo.es.js

Refined state containter for Vue.js

import Vue from 'vue';
import assign from 'nano-assign';

var devtoolHook = typeof window !== 'undefined' && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
function devtoolPlugin(store) {
  if (!devtoolHook) { return; }
  store._devtoolHook = devtoolHook;
  devtoolHook.emit('vuex:init', store);
  devtoolHook.on('vuex:travel-to-state', function (targetState) {
    store.replaceState(targetState);
  });
  store.subscribe(function (mutation, state) {
    devtoolHook.emit('vuex:mutation', mutation, state);
  });
}

var unifyObject = function (type, payload) {
  if (typeof type === 'object') { return type; }
  return {
    type: type,
    payload: payload
  };
};

function zerotwo(Vue$$1) {
  Vue$$1.mixin({
    beforeCreate: function beforeCreate() {
      var store = this.$options.store || this.$parent && this.$parent.$store;

      if (store) {
        this.$store = store;
      }
    }

  });
}
var createStore = function (ref) {
  var state = ref.state;
  var mutations = ref.mutations;
  var getters = ref.getters;
  var actions = ref.actions;
  var plugins = ref.plugins;

  var getterKeys = getters && Object.keys(getters);
  var wrappedGetters = {};

  if (getterKeys) {
    var loop = function () {
      var key = list[i];

      wrappedGetters[key] = function () {
        return getters[key](this._data.$$state, wrappedGetters);
      };
    };

    for (var i = 0, list = getterKeys; i < list.length; i += 1) loop();
  }

  var silent = Vue.config.silent;
  Vue.config.silent = true;
  var vm = new Vue({
    data: {
      $$state: state
    },
    computed: wrappedGetters
  });
  Vue.config.silent = silent;
  var subscribers = [];
  var store = {
    vm: vm,
    committing: false,
    getters: {},

    get state() {
      return vm._data.$$state;
    },

    set state(v) {
      if (process.env.NODE_ENV !== 'production') {
        throw new Error('[zerotwo] Please do not directly mutation store state, use `store.replaceState(newState) instead!`');
      }
    },

    commit: function commit(_type, _payload) {
      var this$1 = this;

      var mutation = unifyObject(_type, _payload);
      var fn = mutations[mutation.type];

      if (process.env.NODE_ENV !== 'production' && !fn) {
        throw new Error(("[zerotwo] Unknown mutation type: " + (mutation.type)));
      }

      this.withCommit(function () { return fn(vm._data.$$state, mutation.payload); });

      for (var i = 0, list = subscribers; i < list.length; i += 1) {
        var sub = list[i];

        sub(mutation, this$1.state);
      }
    },

    dispatch: function dispatch(_type, _payload) {
      var action = unifyObject(_type, _payload);
      var fn = actions[action.type];

      if (process.env.NODE_ENV !== 'production' && !fn) {
        throw new Error(("[zerotwo] Unknown action type: " + (action.type)));
      }

      return Promise.resolve(fn({
        commit: this.commit.bind(this),
        dispatch: this.dispatch.bind(this),
        state: this.state
      }, action.payload));
    },

    subscribe: function subscribe(sub) {
      subscribers.push(sub);
    },

    replaceState: function replaceState(state) {
      this.withCommit(function () {
        vm._data.$$state = state;
      });
    },

    withCommit: function withCommit(fn) {
      var committing = this.committing;
      this.committing = true;
      fn();
      this.committing = committing;
    }

  };

  if (getterKeys) {
    var loop$1 = function () {
      var key$1 = list$1[i$1];

      Object.defineProperty(store.getters, key$1, {
        get: function () { return vm[key$1]; },
        enumerable: true
      });
    };

    for (var i$1 = 0, list$1 = getterKeys; i$1 < list$1.length; i$1 += 1) loop$1();
  } // Strict mode


  if (process.env.NODE_ENV !== 'production') {
    vm.$watch(function () {
      return this._data.$$state;
    }, function () {
      if (!store.committing) {
        throw new Error("[zertwo] Do not mutate store state outside mutation handlers.");
      }
    }, {
      deep: true,
      sync: true
    });
  }

  if (Vue.config.devtools) {
    devtoolPlugin(store);
  }

  if (plugins) {
    for (var i$2 = 0, list$2 = plugins; i$2 < list$2.length; i$2 += 1) {
      var plugin = list$2[i$2];

      plugin(store);
    }
  }

  return store;
};
var STATE = 'STATE';
var MUTATION = 'MUTATION';
var ACTION = 'ACTION';
var GETTER = 'GETTER';

var getPropsFromStore = function (store, obj) {
  return Object.keys(obj).reduce(function (res, key) {
    var def = obj[key];
    var name = def.name || key;
    var value;

    if (def.type === STATE) {
      value = store.state[name];
    } else if (def.type === MUTATION) {
      value = function (payload) { return store.commit(name, payload); };
    } else if (def.type === ACTION) {
      value = function (payload) { return store.dispatch(name, payload); };
    } else if (def.type === GETTER) {
      value = typeof name === 'function' ? function () { return name(store.state, store.getters); } : store.getters[name];
    }

    res[name] = value;
    return res;
  }, {});
};

var connect = function (obj, Comp) {
  if ( obj === void 0 ) obj = {};

  if (!Comp) { return function (Comp) { return connect(obj, Comp); }; }
  return {
    functional: true,
    name: ("connect-" + (Comp.name || 'unknown')),
    props: Comp.props,

    render: function render(h, ctx) {
      var store = ctx.parent.$store;

      if (process.env.NODE_ENV !== 'production' && !store) {
        console.error('Make sure you have called `Vue.use(zerotwo)` and passed `store` in component options!');
      }

      var props = assign({}, ctx.props, getPropsFromStore(store, obj));
      return h(Comp, {
        data: ctx.data,
        on: ctx.listeners,
        props: props
      }, ctx.children);
    }

  };
};
var state = function (name) { return ({
  type: STATE,
  name: name
}); };
var mutation = function (name) { return ({
  type: MUTATION,
  name: name
}); };
var action = function (name) { return ({
  type: ACTION,
  name: name
}); };
var getter = function (name) { return ({
  type: GETTER,
  name: name
}); };

export { createStore, connect, state, mutation, action, getter };
export default zerotwo;