rxact-debugger/dist/rxact-debugger.js

Debugger for rxact

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["rxcat"] = factory();
	else
		root["rxcat"] = factory();
})(this, function() {
return /******/ (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] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = 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;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 4);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_symbol_observable__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_symbol_observable___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_symbol_observable__);


var isObservable = function isObservable(Observable) {
  if (!Observable) {
    return false;
  }

  if (Observable[__WEBPACK_IMPORTED_MODULE_0_symbol_observable___default.a]) {
    return true;
  }

  if (Observable.prototype && Observable.prototype[__WEBPACK_IMPORTED_MODULE_0_symbol_observable___default.a]) {
    return true;
  }

  return false;
};

/* harmony default export */ __webpack_exports__["a"] = (isObservable);

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

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__observable__ = __webpack_require__(2);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__stateFactory__ = __webpack_require__(12);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__combineStateSteams__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__eventRunnerFactory__ = __webpack_require__(14);
var _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; }; }();

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

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






var StateStream = function () {
  function StateStream(streamName, initialState, stateStreams) {
    var _this = this;

    _classCallCheck(this, StateStream);

    this.emitters = {};
    this.subscriptions = [];
    this.observers = [];

    this.dispose = function () {
      _this.subscriptions.forEach(function (subscription) {
        subscription.unsubscribe();
      });
    };

    this.installPlugins = function () {
      var proxy = _this;
      StateStream.plugins.forEach(function (plugin) {
        if (typeof plugin !== 'function') {
          throw new Error('Expected plugin to be a function.');
        }

        var pluginProxy = plugin(proxy);

        if (pluginProxy) {
          proxy = pluginProxy;
        }
      });

      return proxy;
    };

    if (typeof streamName !== 'string' || !streamName) {
      throw new Error('Expected the streamName to be a not none string.');
    }

    this.streamName = streamName;
    this.Observable = Object(__WEBPACK_IMPORTED_MODULE_0__observable__["b" /* getObservable */])();

    this.state$ = __WEBPACK_IMPORTED_MODULE_1__stateFactory__["a" /* default */].call(this, initialState);
    this.state$ = __WEBPACK_IMPORTED_MODULE_2__combineStateSteams__["a" /* default */].call(this, this.state$, streamName, stateStreams);
    this.eventRunner = Object(__WEBPACK_IMPORTED_MODULE_3__eventRunnerFactory__["a" /* default */])(this.Observable, this.getState);
    return this.installPlugins();
  }

  _createClass(StateStream, [{
    key: 'emitter',
    value: function emitter(name, updater) {
      var _this2 = this;

      if (!name) {
        throw new Error('emitter(): name should not be blank.');
      }

      if (typeof updater !== 'function') {
        throw new Error('emitter(): expect second parameter to be a function.');
      }

      // $flow-ignore
      this[name] = function () {
        _this2.next(updater.apply(undefined, arguments));
      };
      // $flow-ignore
      this.emitters[name] = this[name];
    }
  }]);

  return StateStream;
}();

StateStream.plugins = [];

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

  plugins.forEach(function (plugin) {
    if (typeof plugin !== 'function') {
      throw new Error('Expected plugin to be a function.');
    }
  });

  StateStream.plugins = [].concat(_toConsumableArray(StateStream.plugins), plugins);
};

StateStream.removePlugin = function () {
  for (var _len2 = arguments.length, plugins = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    plugins[_key2] = arguments[_key2];
  }

  var finalPlugins = [];
  if (plugins.length !== 0) {
    finalPlugins = StateStream.plugins.filter(function (plugin) {
      return !plugins.find(function (removedPlugin) {
        return removedPlugin === plugin;
      });
    });
  }

  StateStream.plugins = finalPlugins;
};

/* harmony default export */ __webpack_exports__["a"] = (StateStream);

/***/ }),
/* 2 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return setObservable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getObservable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return cleanObservable; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__utils_isObservable__ = __webpack_require__(0);

// https://github.com/tc39/proposal-observable



var Observable = null;

var setObservable = function setObservable(ObservableImplement) {
  if (Object(__WEBPACK_IMPORTED_MODULE_0__utils_isObservable__["a" /* default */])(Observable)) {
    throw new Error('Expected setup once in your app lifetime.');
  }
  Observable = ObservableImplement;
};

var getObservable = function getObservable() {
  if (!Observable) {
    throw Error('You must configure Observable first.');
  }

  return Observable;
};

var cleanObservable = function cleanObservable() {
  Observable = null;
};

/***/ }),
/* 3 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "plugin", function() { return plugin; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "decorator", function() { return decorator; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__debugger__ = __webpack_require__(5);
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "clean", function() { return __WEBPACK_IMPORTED_MODULE_0__debugger__["a"]; });
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }



var plugin = __WEBPACK_IMPORTED_MODULE_0__debugger__["b" /* default */];
var decorator = function decorator(options) {
  var debuggerPlugin = Object(__WEBPACK_IMPORTED_MODULE_0__debugger__["b" /* default */])(options);

  return function (StateStream) {
    return function (_StateStream) {
      _inherits(DebuggableStream, _StateStream);

      function DebuggableStream() {
        var _ref;

        var _this, _ret;

        _classCallCheck(this, DebuggableStream);

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

        var instance = (_this = _possibleConstructorReturn(this, (_ref = DebuggableStream.__proto__ || Object.getPrototypeOf(DebuggableStream)).call.apply(_ref, [this].concat(params))), _this);

        return _ret = debuggerPlugin(instance), _possibleConstructorReturn(_this, _ret);
      }

      return DebuggableStream;
    }(StateStream);
  };
};



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

__webpack_require__(3);
module.exports = __webpack_require__(3);


/***/ }),
/* 5 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return clean; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_rxact__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__logger__ = __webpack_require__(16);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__helpers__ = __webpack_require__(17);
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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

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





var clean = function clean() {
  window.rxactDebugger = undefined;
};

function createDebuggerProxy(instance) {
  var _this = this;

  var streamName = instance.streamName;
  var handler = {
    get: function get(target, prop) {
      if (Object(__WEBPACK_IMPORTED_MODULE_2__helpers__["a" /* isDebugger */])(prop)) {
        return {
          start: function start() {
            _this.isStarted = true;
          },
          stop: function stop() {
            _this.isStarted = false;
          }
        };
      }

      var type = 'operator';

      if (!Object(__WEBPACK_IMPORTED_MODULE_2__helpers__["e" /* isPresent */])(target, prop)) {
        console.warn('Operator does not exist: ' + streamName + '.' + prop);
      }
      if (!Object(__WEBPACK_IMPORTED_MODULE_2__helpers__["d" /* isOperator */])(target, prop) || Object(__WEBPACK_IMPORTED_MODULE_2__helpers__["c" /* isEmitter */])(target.emitters, prop)) {
        return target[prop];
      }

      if (Object(__WEBPACK_IMPORTED_MODULE_2__helpers__["b" /* isDispose */])(prop)) {
        type = 'dispose';
      }

      return function () {
        if (_this.isStarted) {
          Object(__WEBPACK_IMPORTED_MODULE_1__logger__["b" /* operatorLogger */])(type, 'log', streamName, prop);
        }

        return target[prop].apply(target, arguments);
      };
    },
    set: function set(target, prop, value) {
      if (target[prop]) {
        console.warn('Operator redefined: ' + streamName + '.' + prop);
      }
      target[prop] = value;

      return true;
    }
  };

  return new Proxy(instance, handler);
}

function createEmitterProxy(instance) {
  var _this2 = this;

  var handler = {
    apply: function apply(target, thisArg, argumentsList) {
      var _argumentsList = _slicedToArray(argumentsList, 2),
          name = _argumentsList[0],
          emitter = _argumentsList[1];

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

        return function (prevState) {
          var nextState = emitter.apply(undefined, params)(prevState);

          if (_this2.isStarted) {
            Object(__WEBPACK_IMPORTED_MODULE_1__logger__["a" /* emitterLogger */])(instance.streamName, name, prevState, nextState);
          }

          return nextState;
        };
      };

      return target.call(thisArg, name, loggableEmitter);
    }
  };

  return new Proxy(instance.emitter, handler);
}

var isStartDefault = function isStartDefault(start, stream) {
  return start === true || Array.isArray(start) && start.find(function (item) {
    return item === stream;
  });
};

var defaultOptions = {
  start: false
};

var rxactDebugger = function rxactDebugger() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) !== 'object' || Array.isArray(options)) {
    throw new Error('rxact-debugger: Expect options to be an object.');
  }

  return function (instance) {
    var finalOptions = _extends({}, defaultOptions, options);
    var start = finalOptions.start;

    var startDefault = isStartDefault(start, instance.streamName);
    var context = {
      isStarted: false
    };

    var debuggableProxy = createDebuggerProxy.call(context, instance);
    var emitterProxy = createEmitterProxy.call(context, instance);

    instance.emitter = emitterProxy;

    if (!window.rxactDebugger) {
      window.rxactDebugger = {};
    }
    window.rxactDebugger[instance.streamName] = debuggableProxy;

    if (startDefault) {
      debuggableProxy.debugger.start();
    }

    return debuggableProxy;
  };
};

/* harmony default export */ __webpack_exports__["b"] = (rxactDebugger);

/***/ }),
/* 6 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__stateStream__ = __webpack_require__(1);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__helpers__ = __webpack_require__(15);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__observable__ = __webpack_require__(2);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__utils_isObservable__ = __webpack_require__(0);
/* unused harmony reexport StateStream */
/* unused harmony reexport setup */
/* unused harmony reexport teardown */
/* unused harmony reexport getObservable */
/* unused harmony reexport isObservable */







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

module.exports = __webpack_require__(8);


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

"use strict";
/* WEBPACK VAR INJECTION */(function(global, module) {

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

var _ponyfill = __webpack_require__(11);

var _ponyfill2 = _interopRequireDefault(_ponyfill);

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

var root; /* global window */


if (typeof self !== 'undefined') {
  root = self;
} else if (typeof window !== 'undefined') {
  root = window;
} else if (typeof global !== 'undefined') {
  root = global;
} else if (true) {
  root = module;
} else {
  root = Function('return this')();
}

var result = (0, _ponyfill2['default'])(root);
exports['default'] = result;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9), __webpack_require__(10)(module)))

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

var g;

// This works in non-strict mode
g = (function() {
	return this;
})();

try {
	// This works if eval is allowed (see CSP)
	g = g || Function("return this")() || (1,eval)("this");
} catch(e) {
	// This works if the window reference is available
	if(typeof window === "object")
		g = window;
}

// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}

module.exports = g;


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

module.exports = function(module) {
	if(!module.webpackPolyfill) {
		module.deprecate = function() {};
		module.paths = [];
		// module.parent = undefined by default
		if(!module.children) module.children = [];
		Object.defineProperty(module, "loaded", {
			enumerable: true,
			get: function() {
				return module.l;
			}
		});
		Object.defineProperty(module, "id", {
			enumerable: true,
			get: function() {
				return module.i;
			}
		});
		module.webpackPolyfill = 1;
	}
	return module;
};


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

"use strict";


Object.defineProperty(exports, "__esModule", {
	value: true
});
exports['default'] = symbolObservablePonyfill;
function symbolObservablePonyfill(root) {
	var result;
	var _Symbol = root.Symbol;

	if (typeof _Symbol === 'function') {
		if (_Symbol.observable) {
			result = _Symbol.observable;
		} else {
			result = _Symbol('observable');
			_Symbol.observable = result;
		}
	} else {
		result = '@@observable';
	}

	return result;
};

/***/ }),
/* 12 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
var disposedFn = function disposedFn() {
  console.warn('You are calling function on a disposed StateStream.');
};

function stateFactory(initialState) {
  var _this = this;

  var disposed = false;
  var state = initialState;
  this.observers = [];

  this.getState = function () {
    return state;
  };

  this.next = function (updater) {
    if (disposed) {
      return;
    }

    if (typeof updater !== 'function') {
      throw new Error('Expected passing a function to emitState.');
    }

    var nextState = updater(state);
    state = nextState;
    _this.observers.forEach(function (observer) {
      observer.next(nextState);
    });
  };

  var state$ = new this.Observable(function (observer) {
    _this.observers.push(observer);

    observer.next(state);

    return {
      unsubscribe: function unsubscribe() {
        _this.observers = _this.observers.filter(function (item) {
          return item !== observer;
        });
      }
    };
  });

  this.subscriptions.push({
    unsubscribe: function unsubscribe() {
      disposed = true;
      _this.next = disposedFn;

      _this.observers.forEach(function (observer) {
        observer.complete();
      });
      _this.observers = [];
    }
  });

  return state$;
}

/* harmony default export */ __webpack_exports__["a"] = (stateFactory);

/***/ }),
/* 13 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__index__ = __webpack_require__(1);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__utils_isObservable__ = __webpack_require__(0);
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }





function combineStateStreams(state$, streamName, stateStreams) {
  var _this = this;

  if (!stateStreams || stateStreams.length === 0) {
    return state$;
  }

  var streamNames = {};
  var streams = [].concat(_toConsumableArray(stateStreams), [{ streamName: streamName, state$: state$ }]);

  streams.forEach(function (stream) {
    if (!(stream instanceof __WEBPACK_IMPORTED_MODULE_0__index__["a" /* default */]) && (!Object(__WEBPACK_IMPORTED_MODULE_1__utils_isObservable__["a" /* default */])(stream.state$) || !stream.streamName)) {
      throw new Error('Expected the element of stateStreams to be instance of StateStream.');
    }

    streamNames[stream.streamName] = true;
  });

  if (Object.keys(streamNames).length !== streams.length) {
    throw new Error('StateStreams\' name should be unique.');
  }

  var combinedState$ = new this.Observable(function (observer) {
    var currentState = {};

    var subscriptions = streams.map(function (source) {
      return source.state$.subscribe(function (state) {
        var sourceName = source.streamName;

        var nextState = _extends({}, currentState, _defineProperty({}, sourceName, state));
        currentState = nextState;

        if (Object.keys(currentState).length === streams.length) {
          observer.next(currentState);
        }
      });
    });

    _this.subscriptions = _this.subscriptions.concat(subscriptions);

    return {
      unsubscribe: function unsubscribe() {
        subscriptions.forEach(function (subscription) {
          subscription.unsubscribe();
        });
      }
    };
  });

  return combinedState$;
}

/* harmony default export */ __webpack_exports__["a"] = (combineStateStreams);

/***/ }),
/* 14 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__utils_isObservable__ = __webpack_require__(0);




var defaultFactory = function defaultFactory(source) {
  return source;
};

var source$Creator = function source$Creator(inputSource$, Observable, getState) {
  if (inputSource$ === undefined) {
    return Observable.of(getState());
  }

  if (Object(__WEBPACK_IMPORTED_MODULE_0__utils_isObservable__["a" /* default */])(inputSource$)) {
    return inputSource$;
  }

  return Observable.of(inputSource$);
};

var eventRunnerFactory = function eventRunnerFactory(Observable, getState) {
  var eventRunner = function eventRunner(factory, inputSource$) {
    var source$ = source$Creator(inputSource$, Observable, getState);

    if (factory === null || factory === undefined) {
      factory = defaultFactory;
    }

    if (typeof factory !== 'function') {
      throw new Error('Expected first parameter of eventRunner to be a function.');
    }

    var outputSource$ = factory(source$);

    if (!outputSource$ || !Object(__WEBPACK_IMPORTED_MODULE_0__utils_isObservable__["a" /* default */])(outputSource$)) {
      throw new Error('Expected an Observable object returned by factory in eventRunner');
    }

    var output = void 0;
    var next = void 0;
    var subscription = void 0;

    var stream$ = new Observable(function (observer) {
      if (output !== undefined) {
        observer.next(output);
      }

      next = function next(value) {
        return observer.next(value);
      };

      return {
        unsubscribe: function unsubscribe() {
          subscription.unsubscribe();
        }
      };
    });

    subscription = outputSource$.subscribe(function (value) {
      if (typeof next === 'function') {
        next(value);
      }

      output = value;
    });

    return stream$;
  };

  return eventRunner;
};

/* harmony default export */ __webpack_exports__["a"] = (eventRunnerFactory);

/***/ }),
/* 15 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export setup */
/* unused harmony export teardown */
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__stateStream__ = __webpack_require__(1);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__observable__ = __webpack_require__(2);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__utils_isObservable__ = __webpack_require__(0);
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }







var RealStateStream = __WEBPACK_IMPORTED_MODULE_0__stateStream__["a" /* default */];

var setup = function setup(options) {
  var _RealStateStream;

  if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) !== 'object') {
    throw new Error('setup(): Expected options to be an object.');
  }

  var Observable = options.Observable,
      _options$plugins = options.plugins,
      plugins = _options$plugins === undefined ? [] : _options$plugins,
      _options$HOStateStrea = options.HOStateStream,
      HOStateStream = _options$HOStateStrea === undefined ? __WEBPACK_IMPORTED_MODULE_0__stateStream__["a" /* default */] : _options$HOStateStrea;


  if (!Object(__WEBPACK_IMPORTED_MODULE_2__utils_isObservable__["a" /* default */])(Observable)) {
    throw new Error('setup(): Expected an ES Observable. For more info: https://github.com/tc39/proposal-observable');
  }

  Object(__WEBPACK_IMPORTED_MODULE_1__observable__["c" /* setObservable */])(Observable);

  if (!Array.isArray(plugins)) {
    throw new Error('setup(): Expected plugins to be an array');
  }

  RealStateStream = HOStateStream;
  (_RealStateStream = RealStateStream).addPlugin.apply(_RealStateStream, _toConsumableArray(plugins));
};

var teardown = function teardown() {
  Object(__WEBPACK_IMPORTED_MODULE_1__observable__["a" /* cleanObservable */])();
  RealStateStream.removePlugin();
};

/***/ }),
/* 16 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return operatorLogger; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return emitterLogger; });
var BOLD = 'font-weight:bold;';
var UNDERLINE = 'text-decoration:underline;';
var COLOR = function COLOR(color) {
  return 'color:' + color + ';';
};

var toObject = function toObject(state) {
  if (state.toJS) {
    return state.toJS();
  }

  return state;
};

var operatorLogger = function operatorLogger(type) {
  var logger = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'log';
  var streamName = arguments[2];
  var operatorName = arguments[3];

  var prefix = '';
  var action = '';
  var color = '';

  switch (type) {
    case 'emitter':
      {
        prefix = 'STATE   ';
        action = 'updated';
        color = '#3dbd7d';
        break;
      }
    case 'dispose':
      {
        prefix = 'DISPOSE   ';
        action = 'disposed';
        color = '#f04134';
        break;
      }
    default:
      {
        prefix = 'OPERATOR';
        action = 'called ';
        color = '#948aec';
        break;
      }
  }

  console[logger]('%c' + prefix + ' %c ' + action + '  %c' + streamName + '->' + operatorName, BOLD + COLOR(color), BOLD + COLOR('#108ee9'), UNDERLINE + BOLD + COLOR('#5a5a5a'));
};

var stateLog = function stateLog(color, content, state) {
  console.log('%c' + content, COLOR(color) + BOLD, state);
};

var emitterLogger = function emitterLogger(streamName, emitterName, prevState, nextState) {
  operatorLogger('emitter', 'groupCollapsed', streamName, emitterName);
  stateLog('#5a5a5a', 'prevState:', toObject(prevState));
  stateLog('#ffce3d', 'nextState:', toObject(nextState));
  console.groupEnd();
};

/***/ }),
/* 17 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export METHOD_BLACK_LIST */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return isOperator; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return isEmitter; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return isDispose; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isDebugger; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return isPresent; });
var METHOD_BLACK_LIST = ['constructor', 'next', 'eventRunner', 'getState', 'emitter'];

var isOperator = function isOperator(target, prop) {
  return typeof target[prop] === 'function' && !METHOD_BLACK_LIST.find(function (method) {
    return method === prop;
  });
};
var isEmitter = function isEmitter(emitters, prop) {
  return !!emitters[prop];
};
var isDispose = function isDispose(prop) {
  return prop === 'dispose';
};
var isDebugger = function isDebugger(prop) {
  return prop === 'debugger';
};
var isPresent = function isPresent(target, prop) {
  return !!target[prop];
};

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