rxact/dist/rxact.js

an observable application management for Javascript apps

(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__(5);
/* 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__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__combineStateSteams__ = __webpack_require__(11);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__eventRunnerFactory__ = __webpack_require__(12);
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 import */ var __WEBPACK_IMPORTED_MODULE_0__stateStream__ = __webpack_require__(1);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__helpers__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__observable__ = __webpack_require__(2);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__utils_isObservable__ = __webpack_require__(0);
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "StateStream", function() { return __WEBPACK_IMPORTED_MODULE_0__stateStream__["a"]; });
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "setup", function() { return __WEBPACK_IMPORTED_MODULE_1__helpers__["a"]; });
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "teardown", function() { return __WEBPACK_IMPORTED_MODULE_1__helpers__["b"]; });
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "getObservable", function() { return __WEBPACK_IMPORTED_MODULE_2__observable__["b"]; });
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "isObservable", function() { return __WEBPACK_IMPORTED_MODULE_3__utils_isObservable__["a"]; });







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

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


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

module.exports = __webpack_require__(6);


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

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

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

var _ponyfill = __webpack_require__(9);

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__(7), __webpack_require__(8)(module)))

/***/ }),
/* 7 */
/***/ (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;


/***/ }),
/* 8 */
/***/ (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;
};


/***/ }),
/* 9 */
/***/ (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;
};

/***/ }),
/* 10 */
/***/ (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);

/***/ }),
/* 11 */
/***/ (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);

/***/ }),
/* 12 */
/***/ (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);

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

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return setup; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return 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();
};

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