@airyrooms/catela/dist/catela.build.client.js

exports["client"] =
/******/ (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;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// 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 = 5);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {

module.exports = require("react");

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

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
var scrollToY = function scrollToY() {};
try {
  // first add raf shim
  // http://www.paulirish.com/2011/requestanimationframe-for-smart-animating/
  window.requestAnimFrame = function () {
    return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || function (callback) {
      window.setTimeout(callback, 1000 / 60);
    };
  }();

  // main function
  scrollToY = function scrollToY(scrollTargetY, speed, easing) {
    // scrollTargetY: the target scrollY property of the window
    // speed: time in pixels per second
    // easing: easing equation to use

    var scrollY = window.scrollY,
        scrollTargetY = scrollTargetY || 0,
        speed = speed || 2000,
        easing = easing || 'easeOutSine',
        currentTime = 0;

    // min time .1, max time .8 seconds
    var time = Math.max(0.1, Math.min(Math.abs(scrollY - scrollTargetY) / speed, 0.8));

    // easing equations from https://github.com/danro/easing-js/blob/master/easing.js
    var PI_D2 = Math.PI / 2,
        easingEquations = {
      easeOutSine: function easeOutSine(pos) {
        return Math.sin(pos * (Math.PI / 2));
      },
      easeInOutSine: function easeInOutSine(pos) {
        return -0.5 * (Math.cos(Math.PI * pos) - 1);
      },
      easeInOutQuint: function easeInOutQuint(pos) {
        if ((pos /= 0.5) < 1) {
          return 0.5 * Math.pow(pos, 5);
        }
        return 0.5 * (Math.pow(pos - 2, 5) + 2);
      }

      // add animation loop
    };function tick() {
      currentTime += 1 / 60;

      var p = currentTime / time;
      var t = easingEquations[easing](p);

      if (p < 1) {
        window.requestAnimFrame(tick);
        window.scrollTo(0, scrollY + (scrollTargetY - scrollY) * t);
      } else {
        window.scrollTo(0, scrollTargetY);
      }
    }

    tick();
  };
} catch (err) {/* Suppressing */}

exports.default = {
  scrollToY: scrollToY
};
module.exports = exports['default'];

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


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

module.exports = require("async");

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

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

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

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

__webpack_require__(11);

var _async = __webpack_require__(3);

var _async2 = _interopRequireDefault(_async);

var _core = __webpack_require__(9);

var _history = __webpack_require__(15);

var _querystring = __webpack_require__(17);

var _querystring2 = _interopRequireDefault(_querystring);

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _cookie = __webpack_require__(14);

var _cookie2 = _interopRequireDefault(_cookie);

var _reactDom = __webpack_require__(18);

var _reactRedux = __webpack_require__(19);

var _reactRouter = __webpack_require__(20);

var _redux = __webpack_require__(21);

var _reduxThunk = __webpack_require__(23);

var _reduxThunk2 = _interopRequireDefault(_reduxThunk);

var _UniversalPageHandler = __webpack_require__(12);

var _UniversalPageHandler2 = _interopRequireDefault(_UniversalPageHandler);

var _InternationalizationHandler = __webpack_require__(13);

var _InternationalizationHandler2 = _interopRequireDefault(_InternationalizationHandler);

var _scrollToAnimation = __webpack_require__(1);

var _reduxDevtoolsExtension = __webpack_require__(22);

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

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

var logger = global.Logger.getLogger('UniversalApplicationClient');

var QS_REGEX = /^\?(.*)$/;

/**
 * This devTools is used for debugging purpose only
 * Integrated with Chrome's extension, ReduxDevTools
*/
var createStoreWithMiddleWareAndDevTools = (0, _reduxDevtoolsExtension.composeWithDevTools)((0, _redux.applyMiddleware)(_reduxThunk2.default))(_redux.createStore);

var createStoreWithMiddleware = (0, _redux.applyMiddleware)(_reduxThunk2.default)(_redux.createStore);

var UniversalApplicationClient = function () {
  function UniversalApplicationClient(options) {
    _classCallCheck(this, UniversalApplicationClient);

    logger.info('Initializing web application client.', this._options);
    this._options = options;
    this._initialize();
  }

  _createClass(UniversalApplicationClient, [{
    key: '_initialize',
    value: function _initialize() {
      this._setupReducers();
      this._setupStore();
      this._setupRouting();
      this._setupBrowserHistory();
      this._setupViewContainer();
    }
  }, {
    key: '_setupReducers',
    value: function _setupReducers() {
      var reducers = this.getReducers();
      var allReducers = _extends({}, reducers, {
        view: _core.serverFetchReducer
      });
      this._reducers = allReducers;
    }
  }, {
    key: '_setupStore',
    value: function _setupStore() {
      // TODO: change to config element, or... not
      if (__PROJECT__.environment === 'development' || __PROJECT__.environment === 'staging') {
        this._store = createStoreWithMiddleWareAndDevTools((0, _redux.combineReducers)(this._reducers));
      } else {
        this._store = createStoreWithMiddleware((0, _redux.combineReducers)(this._reducers));
      }
    }
  }, {
    key: '_setupRouting',
    value: function _setupRouting() {
      var finalRoutes = null;
      var originalRoutes = this.getRoutes();
      var generatedRoutes = [];
      this._options.locales.forEach(function (locale) {
        var internationalRoute = _react2.default.createElement(
          _reactRouter.Route,
          { key: locale, path: locale, component: _InternationalizationHandler2.default },
          originalRoutes
        );
        generatedRoutes.push(internationalRoute);
      });

      generatedRoutes.push(originalRoutes);
      finalRoutes = _react2.default.createElement(
        _reactRouter.Route,
        { path: '/', component: _UniversalPageHandler2.default },
        generatedRoutes.map(function (route) {
          return route;
        })
      );
      this._routes = finalRoutes;
    }
  }, {
    key: '_runFilterPreFetchStage',
    value: function _runFilterPreFetchStage(filterQueue, renderProps, renderedServerComponents, context, callback) {
      var _this = this;

      if (filterQueue.length > 0) {
        var filterFnQueue = [];
        filterQueue.reverse().forEach(function (filterFn) {
          filterFnQueue.push(function (ccallback) {
            var filterCallContext = {
              get: function get() {
                return context;
              },
              next: function next(booleanResult) {
                if (typeof booleanResult === 'undefined' || booleanResult == null) {
                  booleanResult = true;
                }
                ccallback(null, booleanResult);
              },
              redirect: function redirect(_redirect) {
                ccallback({ type: 'REDIRECTION', redirect: _redirect }, false);
              },
              notFound: function notFound() {
                ccallback({ type: 'NOT_FOUND' }, false);
              }
            };
            filterFn(filterCallContext);
          });
        });
        _async2.default.series(filterFnQueue, function (err, results) {
          if (err) {
            if (err.type === 'REDIRECTION') {
              _this._store.dispatch({
                type: '__ROUTE_FINISH_TRANSITION__'
              });
              callback(false);
              return _this._history.replace(err.redirect);
            } else if (err.type === 'NOT_FOUND') {
              logger.error('[404] URL not found. Redirecting to HOME_PAGE');
              _this._store.dispatch({
                type: '__ROUTE_FINISH_TRANSITION__'
              });
              callback(false);
              return _this._history.replace('/');
            } else {
              // TODO what case need to be handled?
            }
          } else {
            _this._runFetchStage(renderProps, renderedServerComponents, context, callback);
          }
        });
      } else {
        this._runFetchStage(renderProps, renderedServerComponents, context, callback);
      }
    }
  }, {
    key: '_runFetchStage',
    value: function _runFetchStage(renderProps, renderedServerComponents, context, callback) {
      var _this2 = this;

      var fetchDataQueue = [];
      var dataContextObject = {};

      renderedServerComponents.forEach(function (rsc) {
        if (rsc.__fetchData != null && typeof rsc.__fetchData !== 'undefined') {
          var fnFetchCall = function fnFetchCall(callback) {
            setTimeout(function () {
              rsc.__fetchData(dataContextObject, context, callback);
            }, 1);
          };
          fetchDataQueue.push(fnFetchCall);
        }
      });

      _async2.default.series(fetchDataQueue, function (err, results) {
        if (err) {
          logger.error('[500] An error occurred. Redirecting to HOME_PAGE');
          _this2._store.dispatch({
            type: '__ROUTE_FINISH_TRANSITION__'
          });
          callback(false);
          return _this2._history.replace('/');
        } else {
          var fetchedDataContext = {};
          results.forEach(function (result) {
            fetchedDataContext = _extends({}, fetchedDataContext, result);
          });

          _this2._store.dispatch({
            type: '__SET_VIEW_STATE__',
            data: fetchedDataContext
          });

          var postFetchFilterQueue = [];

          renderedServerComponents.forEach(function (rsc) {
            if (rsc.__postFetchFilter != null && typeof rsc.__postFetchFilter !== 'undefined') {
              postFetchFilterQueue = postFetchFilterQueue.concat(rsc.__postFetchFilter);
            }
          });

          _this2._runFilterPostFetchStage(postFetchFilterQueue, renderedServerComponents, context, callback);
        }
      });
    }
  }, {
    key: '_runFilterPostFetchStage',
    value: function _runFilterPostFetchStage(filterQueue, renderedServerComponents, context, callback) {
      var _this3 = this;

      var _store = this._store;

      if (filterQueue.length > 0) {
        var filterFnQueue = [];
        filterQueue.reverse().forEach(function (filterFn) {
          filterFnQueue.push(function (ccallback) {
            var filterCallContext = {
              store: function store() {
                return _store.getState().view;
              },
              get: function get() {
                return context;
              },
              next: function next(booleanResult) {
                if (typeof booleanResult === 'undefined' || booleanResult == null) {
                  booleanResult = true;
                }
                ccallback(null, booleanResult);
              },
              redirect: function redirect(_redirect2) {
                ccallback({ type: 'REDIRECTION', redirect: _redirect2 }, false);
              },
              notFound: function notFound() {
                ccallback({ type: 'NOT_FOUND' }, false);
              }
            };
            filterFn(filterCallContext);
          });
        });
        _async2.default.series(filterFnQueue, function (err, results) {
          if (err) {
            if (err.type === 'REDIRECTION') {
              _store.dispatch({
                type: '__ROUTE_FINISH_TRANSITION__'
              });
              callback(true);
              return _this3._history.replace(err.redirect);
            } else if (err.type === 'NOT_FOUND') {
              logger.error('[404] URL not found. Redirecting to HOME_PAGE');
              _store.dispatch({
                type: '__ROUTE_FINISH_TRANSITION__'
              });
              callback(false);
              return _this3._history.replace('/');
            } else {
              // TODO what case need to be handled?
            }
          } else {
            _this3._store.dispatch({
              type: '__ROUTE_FINISH_TRANSITION__'
            });
            return callback(true);
          }
        });
      } else {
        this._store.dispatch({
          type: '__ROUTE_FINISH_TRANSITION__'
        });
        return callback(true);
      }
    }
  }, {
    key: '_importRequestCookie',
    value: function _importRequestCookie(context) {
      var parsedCookie = _cookie2.default.parse(document.cookie);
      context.request.cookies = parsedCookie;
    }
  }, {
    key: '_setupBrowserHistory',
    value: function _setupBrowserHistory() {
      var _this4 = this;

      this._history = (0, _history.createHistory)();
      this._history.listenBefore(function (location, callback) {
        var routes = _this4._routes;

        _this4._store.dispatch({
          type: '__ROUTE_START_TRANSITION__'
        });

        (0, _scrollToAnimation.scrollToY)(0, 10000, 'easeInOutQuint');
        (0, _reactRouter.match)({ routes: routes, location: location }, function (err, redirectLocation, renderProps) {
          if (err) {
            logger.error('[MATCH_FATAL_ERROR] Unknown error occurred.', err);
            _this4._store.dispatch({
              type: '__ROUTE_FINISH_TRANSITION__'
            });
            callback(false);
          }

          if (!renderProps) {
            logger.error('[ROUTES_NOT_FOUND] An error occurred when trying to match routes. Routes not found.', {});
            _this4._store.dispatch({
              type: '__ROUTE_FINISH_TRANSITION__'
            });
            callback(false);
          } else {
            var query = {};
            var queryStringMatch = QS_REGEX.exec(location.search);
            var queryString = '';
            if (queryStringMatch != null && typeof queryStringMatch !== 'undefined') {
              queryString = queryStringMatch[1];
            }
            if (queryString != null && typeof queryString !== 'undefined') {
              query = _querystring2.default.parse(queryString);
            }

            var simplifiedRoutes = {
              name: renderProps.routes[renderProps.routes.length - 1].name,
              path: renderProps.routes[renderProps.routes.length - 1].path
            };

            var url = location.pathname;
            if (location.search != null && typeof location.search !== 'undefined') {
              url += location.search;
            }

            var context = {
              host: _this4._options.applicationHost,
              url: url,
              locale: null, // TODO how to handle this properly
              params: renderProps.params,
              query: query,
              routes: simplifiedRoutes,
              path: location.pathname,
              environment: _this4._options.environment,
              server: false,
              client: true,
              request: {
                cookies: {},
                headers: {},
                meta: {}
              },
              response: {
                cookies: {},
                headers: {},
                meta: {}
              }
            };

            _this4._importRequestCookie(context);

            var renderedServerComponents = renderProps.components;
            var preFetchFilterQueue = [];

            renderedServerComponents.forEach(function (rsc) {
              if (rsc.__preFetchFilter != null && typeof rsc.__preFetchFilter !== 'undefined') {
                preFetchFilterQueue = preFetchFilterQueue.concat(rsc.__preFetchFilter);
              }
            });

            _this4._runFilterPreFetchStage(preFetchFilterQueue, renderProps, renderedServerComponents, context, callback);
          }
        });
      });
    }
  }, {
    key: '_setupViewContainer',
    value: function _setupViewContainer() {
      this._viewContainer = this._options.viewContainer;
    }
  }, {
    key: 'run',
    value: function run() {
      this._store.dispatch({
        type: '__SET_VIEW_STATE__',
        data: this._options.initialState.view
      });
      (0, _reactDom.render)(_react2.default.createElement(
        _reactRedux.Provider,
        { store: this._store },
        _react2.default.createElement(_reactRouter.Router, { children: this._routes, history: this._history })
      ), this._viewContainer);
    }
  }]);

  return UniversalApplicationClient;
}();

exports.default = UniversalApplicationClient;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))

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

"use strict";


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

var _UniversalApplicationClient = __webpack_require__(4);

var _UniversalApplicationClient2 = _interopRequireDefault(_UniversalApplicationClient);

var _scrollToAnimation = __webpack_require__(1);

var _scrollToAnimation2 = _interopRequireDefault(_scrollToAnimation);

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

exports.default = {
  CatelaApplicationClient: _UniversalApplicationClient2.default,
  util: {
    scrollToAnimation: _scrollToAnimation2.default
  }
};
module.exports = exports['default'];

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

"use strict";


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

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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DataFetch = function () {
  function DataFetch() {
    _classCallCheck(this, DataFetch);
  }

  _createClass(DataFetch, [{
    key: "fetch",
    value: function fetch(store, context, callback) {}
  }]);

  return DataFetch;
}();

exports.default = DataFetch;
module.exports = exports["default"];

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

"use strict";


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

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

var _DataFetch2 = __webpack_require__(6);

var _DataFetch3 = _interopRequireDefault(_DataFetch2);

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

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 FetchableInstance = function (_DataFetch) {
  _inherits(FetchableInstance, _DataFetch);

  function FetchableInstance(FetchClass) {
    _classCallCheck(this, FetchableInstance);

    var _this = _possibleConstructorReturn(this, (FetchableInstance.__proto__ || Object.getPrototypeOf(FetchableInstance)).call(this));

    _this._innerFetchInstance = new FetchClass();
    _this._innerFetchInstance.disableClient = FetchClass.disableClient;
    return _this;
  }

  _createClass(FetchableInstance, [{
    key: 'fetch',
    value: function fetch(store, context, callback) {
      this._innerFetchInstance.fetch(store, context, function (err, results) {
        callback(err, results);
      });
    }
  }, {
    key: 'disableClient',
    value: function disableClient() {
      return this._innerFetchInstance.disableClient;
    }
  }]);

  return FetchableInstance;
}(_DataFetch3.default);

exports.default = FetchableInstance;
module.exports = exports['default'];

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

"use strict";


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

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

var _FetchableInstance = __webpack_require__(7);

var _FetchableInstance2 = _interopRequireDefault(_FetchableInstance);

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

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

var FetchableInstanceFactory = function () {
  function FetchableInstanceFactory() {
    _classCallCheck(this, FetchableInstanceFactory);

    this._dataFetchInstanceCache = new Map();
  }

  _createClass(FetchableInstanceFactory, [{
    key: 'getFetchableInstance',
    value: function getFetchableInstance(FetchClass) {
      var construct = true;
      if (FetchClass.KeyProperty != null && typeof FetchClass.KeyProperty !== 'undefined') {
        if (FetchClass.EnableCache === true) {
          if (this._dataFetchInstanceCache.get(FetchClass.Key) != null && typeof FetchClass.Key !== 'undefined') {
            construct = false;
          }
        }
      }
      if (construct) {
        var fetchableInstance = new _FetchableInstance2.default(FetchClass);
        this._dataFetchInstanceCache.set(FetchClass.KeyProperty, fetchableInstance);
        return fetchableInstance;
      } else {
        return this._dataFetchInstanceCache.get(FetchClass.Key);
      }
    }
  }]);

  return FetchableInstanceFactory;
}();

exports.default = FetchableInstanceFactory;
module.exports = exports['default'];

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

"use strict";


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

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

var _async = __webpack_require__(3);

var _async2 = _interopRequireDefault(_async);

var _FetchableInstanceFactory = __webpack_require__(8);

var _FetchableInstanceFactory2 = _interopRequireDefault(_FetchableInstanceFactory);

var _hoistNonReactStatics = __webpack_require__(16);

var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);

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

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 fetchableInstanceFactory = new _FetchableInstanceFactory2.default();

function getDisplayName(WrappedComponent) {
  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
}

function fetch(fetchClasses) {
  return function wrapWithFetch(WrappedComponent) {
    var fetchableDisplayName = 'Fetchable(' + getDisplayName(WrappedComponent) + ')';

    var FetchableWrappedComponent = function (_WrappedComponent) {
      _inherits(FetchableWrappedComponent, _WrappedComponent);

      function FetchableWrappedComponent(props, context) {
        _classCallCheck(this, FetchableWrappedComponent);

        var _this = _possibleConstructorReturn(this, (FetchableWrappedComponent.__proto__ || Object.getPrototypeOf(FetchableWrappedComponent)).call(this, props, context));

        _this.fetch = {};
        _this.model = _this.context.model;
        return _this;
      }

      _createClass(FetchableWrappedComponent, [{
        key: 'render',
        value: function render() {
          return this.__innerRender();
        }
      }]);

      return FetchableWrappedComponent;
    }(WrappedComponent);

    FetchableWrappedComponent.displayName = fetchableDisplayName;
    FetchableWrappedComponent.prototype.__innerRender = WrappedComponent.prototype.render;
    FetchableWrappedComponent.__fetchData = function (store, context, callback) {
      if (typeof fetchClasses !== 'undefined' && fetchClasses != null) {
        var asyncCalls = {};
        Object.keys(fetchClasses).forEach(function (kc) {
          asyncCalls[kc] = function (callback) {
            var fetchDataInstance = fetchableInstanceFactory.getFetchableInstance(fetchClasses[kc]);
            if (fetchDataInstance.disableClient() && !context.server) {
              callback(null, []);
            } else {
              fetchDataInstance.fetch(store, context, function (err, results) {
                if (err) {
                  console.log('[' + kc + '] Unknown error occurred when trying to fetch data. ', err);
                  callback(err, null);
                } else {
                  store[kc] = results;
                  callback(null, results);
                }
              });
            }
          };
        });
        _async2.default.series(asyncCalls, function (err, results) {
          if (err) {
            callback(err, null);
          } else {
            callback(null, results);
          }
        });
      } else {
        callback(null, store);
      }
    };
    return (0, _hoistNonReactStatics2.default)(FetchableWrappedComponent, WrappedComponent);
  };
}

function simpleReducer() {
  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var action = arguments[1];

  switch (action.type) {
    case '__SET_VIEW_STATE__':
      var newState = _extends({}, state, action.data);
      return newState;
    default:
      return state;
  }
  return state;
}

exports.default = {
  fetch: fetch,
  serverFetchReducer: simpleReducer
};
module.exports = exports['default'];

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

"use strict";


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

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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var LoggerComponent = function () {
  function LoggerComponent(context) {
    _classCallCheck(this, LoggerComponent);

    this._context = context;
    this.init();
  }

  _createClass(LoggerComponent, [{
    key: 'init',
    value: function init() {
      this._logger = console;
    }
  }, {
    key: 'getLogger',
    value: function getLogger() {
      return this._logger;
    }
  }]);

  return LoggerComponent;
}();

var DecoratedContextLogger = function () {
  function DecoratedContextLogger(logger, logContextName) {
    _classCallCheck(this, DecoratedContextLogger);

    this._context = logContextName;
    this._logger = logger;
  }

  _createClass(DecoratedContextLogger, [{
    key: 'log',
    value: function log(level, _log, data) {
      this._logger.log(level, '[' + this._context + '] ' + _log, data);
    }
  }, {
    key: 'view',
    value: function view(data) {
      var dataObj = {};
      if (typeof data !== 'undefined' && data !== null) {
        dataObj.data = data;
      }
      this._logger.log('info', '[' + this._context + '] ', dataObj);
    }
  }, {
    key: 'info',
    value: function info(log, data) {
      var dataObj = {};
      if (typeof data !== 'undefined' && data !== null) {
        dataObj.data = data;
      }
      this._logger.log('info', '[' + this._context + '] ' + log, dataObj);
    }
  }, {
    key: 'warn',
    value: function warn(log, data) {
      var dataObj = {};
      if (typeof data !== 'undefined' && data != null) {
        dataObj.data = data;
      }
      this._logger.log('warn', '[' + this._context + '] ' + log, dataObj);
    }
  }, {
    key: 'error',
    value: function error(log, exception, data) {
      var dataObj = {};
      if (typeof data !== 'undefined' && data != null) {
        dataObj.data = data;
      }
      if (typeof exception !== 'undefined' && exception != null) {
        dataObj.ex = exception;
      }
      this._logger.log('error', '[' + this._context + '] ' + log, {
        stackTrace: exception.stack,
        data: dataObj.data
      });
    }
  }, {
    key: 'debug',
    value: function debug(log, data) {
      var dataObj = {};
      if (typeof data !== 'undefined' && data != null) {
        dataObj.data = data;
      }
      this._logger.log('debug', '[' + this._context + '] ' + log, dataObj);
    }
  }]);

  return DecoratedContextLogger;
}();

var LogManager = function () {
  function LogManager(loggerComponent) {
    _classCallCheck(this, LogManager);

    this._loggerComponent = loggerComponent;
  }

  _createClass(LogManager, [{
    key: 'getLogger',
    value: function getLogger(logContextName) {
      var decoratedLogger = new DecoratedContextLogger(this._loggerComponent.getLogger(), logContextName);
      return decoratedLogger;
    }
  }]);

  return LogManager;
}();

exports.default = {
  configure: function configure(context) {
    var contextLoggerComponent = new LoggerComponent(context);
    return new LogManager(contextLoggerComponent);
  }
};
module.exports = exports['default'];

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

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

var _ClientLoggerComponent = __webpack_require__(10);

var _ClientLoggerComponent2 = _interopRequireDefault(_ClientLoggerComponent);

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

var project = __PROJECT__;

(function installClientLogger() {
  if (global.Logger === null || typeof global.Logger === 'undefined') {
    global.Logger = _ClientLoggerComponent2.default.configure(project.applicationName);
  }
})();
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))

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

"use strict";


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

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

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

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

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 UniversalPageHandler = function (_React$Component) {
  _inherits(UniversalPageHandler, _React$Component);

  function UniversalPageHandler() {
    _classCallCheck(this, UniversalPageHandler);

    return _possibleConstructorReturn(this, (UniversalPageHandler.__proto__ || Object.getPrototypeOf(UniversalPageHandler)).apply(this, arguments));
  }

  _createClass(UniversalPageHandler, [{
    key: 'render',
    value: function render() {
      return _react2.default.createElement(
        'div',
        null,
        this.props.children
      );
    }
  }]);

  return UniversalPageHandler;
}(_react2.default.Component);

UniversalPageHandler.propTypes = {
  children: _react2.default.PropTypes.any
};

exports.default = UniversalPageHandler;
module.exports = exports['default'];

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

"use strict";


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

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

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

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

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 InternationalizationHandler = function (_React$Component) {
  _inherits(InternationalizationHandler, _React$Component);

  function InternationalizationHandler() {
    _classCallCheck(this, InternationalizationHandler);

    return _possibleConstructorReturn(this, (InternationalizationHandler.__proto__ || Object.getPrototypeOf(InternationalizationHandler)).call(this));
  }

  _createClass(InternationalizationHandler, [{
    key: 'render',
    value: function render() {
      return _react2.default.createElement(
        'div',
        null,
        this.props.children
      );
    }
  }]);

  return InternationalizationHandler;
}(_react2.default.Component);

InternationalizationHandler.propTypes = {
  children: _react2.default.PropTypes.any
};

InternationalizationHandler.contextTypes = {
  intl: _react2.default.PropTypes.object
};

exports.default = InternationalizationHandler;
module.exports = exports['default'];

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

module.exports = require("cookie");

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

module.exports = require("history");

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

module.exports = require("hoist-non-react-statics");

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

module.exports = require("querystring");

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

module.exports = require("react-dom");

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

module.exports = require("react-redux");

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

module.exports = require("react-router");

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

module.exports = require("redux");

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

module.exports = require("redux-devtools-extension");

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

module.exports = require("redux-thunk");

/***/ })
/******/ ]);
//# sourceMappingURL=catela.build.client.js.map