revue/revue.common.js

module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(1);


/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var _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"); } }; })();

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});

	exports.default = function (Vue, options) {
	  // const _ = Vue.util
	  var store = options.store;
	  var re = /([a-zA-Z0-9\._-]+)\s{1,2}as\s{1,2}([a-zA-Z0-9\._-]+)/i;
	  // bring redux to revue
	  Object.defineProperties(Vue.prototype, {
	    '$revue': {
	      value: store
	    },
	    '$subscribe': {
	      value: function value() {
	        var _this = this;

	        // unsubscribe old listeners if ever subscribed
	        this.$unsubscribe();
	        this.unsubscriber = [];

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

	        args.forEach(function (prop) {
	          // realProp: property name/path in your instance
	          // storeProp: property name/path in Redux store
	          var realProp = prop,
	              storeProp = prop;
	          if (re.test(prop)) {
	            var _prop$match = prop.match(re);

	            var _prop$match2 = _slicedToArray(_prop$match, 3);

	            storeProp = _prop$match2[1];
	            realProp = _prop$match2[2];
	          }
	          var currentValue = (0, _objectPath.get)(store.getState(), storeProp);
	          var handleChange = function handleChange() {
	            var previousValue = currentValue;
	            currentValue = (0, _objectPath.get)(store.getState(), storeProp);
	            if (!(0, _shallowEqual2.default)(previousValue, currentValue)) {
	              (0, _objectPath.set)(_this._data, realProp, currentValue);
	            }
	          };
	          _this.unsubscriber.push(store.subscribe(handleChange));
	        });
	      }
	    },
	    '$unsubscribe': {
	      value: function value() {
	        if (this.unsubscriber && this.unsubscriber.length > 0) {
	          this.unsubscriber.forEach(function (un) {
	            return un();
	          });
	        }
	      }
	    }
	  });
	  // global mixin
	  Vue.mixin({
	    beforeDestroy: function beforeDestroy() {
	      this.$unsubscribe();
	    }
	  });
	};

	var _objectPath = __webpack_require__(3);

	var _shallowEqual = __webpack_require__(2);

	var _shallowEqual2 = _interopRequireDefault(_shallowEqual);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ },
/* 2 */
/***/ function(module, exports) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = shallowEqual;

	function _typeof(obj) { return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; }

	// credit: @gaearon
	// borrowed from https://github.com/rackt/react-redux/blob/master/src%2Futils%2FshallowEqual.js
	// with some modifications.

	function shallowEqual(objA, objB) {
	  // objA and objB is the same type
	  if ((typeof objA === 'undefined' ? 'undefined' : _typeof(objA)) === 'object') {
	    if (objA === objB) {
	      return true;
	    }

	    var keysA = Object.keys(objA);
	    var keysB = Object.keys(objB);

	    if (keysA.length !== keysB.length) {
	      return false;
	    }

	    // Test for A's keys different from B.
	    var hasOwn = Object.prototype.hasOwnProperty;
	    for (var i = 0; i < keysA.length; i++) {
	      if (!hasOwn.call(objB, keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {
	        return false;
	      }
	    }

	    return true;
	  } else {
	    return objA === objB;
	  }
	}

/***/ },
/* 3 */
/***/ function(module, exports) {

	module.exports = require("object-path");

/***/ }
/******/ ]);