revue/revue.common.js

'use strict';

var babelHelpers = {};

babelHelpers.classCallCheck = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

babelHelpers.createClass = function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();

babelHelpers.slicedToArray = function () {
  function sliceIterator(arr, i) {
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"]) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  return function (arr, i) {
    if (Array.isArray(arr)) {
      return arr;
    } else if (Symbol.iterator in Object(arr)) {
      return sliceIterator(arr, i);
    } else {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }
  };
}();

babelHelpers;

// to valid and match like `a.b.c as x.y.z`
var re = /^([a-zA-Z0-9_-]+)\s{1,2}as\s{1,2}([a-zA-Z0-9\._-]+)$/i;

var isDev = process.env.NODE_ENV !== 'production';

/**
 * Bind reduxStore to Vue instance
 *
 * @param {Vue} Vue
 * @param {object} store - redux store
 */
function bindVue(Vue, store) {
	Vue.prototype.$subscribe = function () {
		var _this = this;

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
			args[_key] = arguments[_key];
		}

		if (this._calledOnce) {
			if (isDev) {
				throw new Error('[Revue] You can only subscribe once, pass multi args to subscribe more than one state.');
			}
			return false;
		}
		this._calledOnce = true;
		var handleChange = function handleChange() {
			args.forEach(function (prop) {
				// realProp: property name/path in your instance
				// storeProp: property name/path in Redux store
				var realProp = prop;
				var storeProp = prop;
				if (re.test(prop)) {
					var _prop$match = prop.match(re);

					var _prop$match2 = babelHelpers.slicedToArray(_prop$match, 3);

					storeProp = _prop$match2[1];
					realProp = _prop$match2[2];
				}
				if (realProp && storeProp) {
					var currentValue = store.getState()[storeProp];
					_this.$set(realProp, currentValue);
				}
			});
		};
		this._unsubscribe = store.subscribe(handleChange);
		Vue.mixin({
			beforeDestroy: function beforeDestroy() {
				if (this._unsubscribe) {
					this._calledOnce = false;
					this.unsubscribe();
				}
			}
		});
	};
}

var Revue = function () {
	function Revue(Vue, reduxStore, reduxActions) {
		babelHelpers.classCallCheck(this, Revue);

		this.store = reduxStore;
		bindVue(Vue, this.store);
		if (reduxActions) {
			this.reduxActions = reduxActions;
		}
	}

	babelHelpers.createClass(Revue, [{
		key: 'dispatch',
		value: function dispatch() {
			for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
				args[_key2] = arguments[_key2];
			}

			this.store.dispatch.apply(null, args);
			return this;
		}
	}, {
		key: 'state',
		get: function get() {
			return this.store.getState();
		}
	}, {
		key: 'actions',
		get: function get() {
			if (isDev && !this.reduxActions) {
				throw new Error('[Revue] Binding actions to Revue before calling them!');
			}
			return this.reduxActions;
		}
	}]);
	return Revue;
}();

module.exports = Revue;