eunomia-controller/distribution/redux/router/index.js

'use strict';

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 _react = require('react');

var _react2 = _interopRequireDefault(_react);

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

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 _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }

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 decodeParam = function decodeParam(val) {
  if (!(typeof val === 'string' || val.length === 0)) {
    return val;
  }
  try {
    return decodeURIComponent(val);
  } catch (err) {
    if (err instanceof URIError) {
      err.message = 'Failed to decode param \'' + val + '\'';
      err.status = 400;
    }
    throw err;
  }
};

var matchURI = function matchURI(route, path) {
  var match = route.pattern.exec(path);

  if (!match) {
    return null;
  }

  var params = Object.create(null);

  for (var i = 1; i < match.length; i += 1) {
    params[route.keys[i - 1].name] = match[i] !== undefined ? decodeParam(match[i]) : undefined;
  }

  return params;
};

var error = function error(text, code) {
  var error = new Error(text);
  error.status = code;
  return Promise.reject(error);
};

module.exports = function (routes, context) {
  if (typeof routes === 'undefined') {
    var _error = new Error('A `error` page module is missing under your views');
    _error.status = 404;
    return Promise.reject(_error);
  } else {
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      var _loop = function _loop() {
        var route = _step.value;

        var params = matchURI(route, context.error ? '/error' : context.pathname);

        if (!params) {
          return 'continue';
        }

        if (route.data) {
          var keys = Object.keys(route.data);
          return {
            v: Promise.all([route.load()].concat(_toConsumableArray(keys.map(function (key) {
              var query = route.data[key];
              var method = query.substring(0, query.indexOf(' '));
              var url = query.substr(query.indexOf(' ') + 1);
              // TODO: Optimize
              Object.keys(params).forEach(function (k) {
                url = url.replace('' + k, params[k]);
              });
              return fetch(url, { method: method }).then(function (resp) {
                return resp.json();
              });
            })))).then(function (_ref) {
              var _ref2 = _toArray(_ref),
                  Page = _ref2[0],
                  data = _ref2.slice(1);

              var props = keys.reduce(function (result, key, i) {
                return _extends({}, result, _defineProperty({}, key, data[i]));
              }, {});
              return _react2.default.createElement(Page, _extends({ route: _extends({}, route, { params: params }), error: context.error }, props));
            })
          };
        }
        return {
          v: route.load().then(function (Page) {
            // Set the page title
            if (typeof route.title === 'undefined') {
              return error('a route requires a \'title\' json string field', 404);
            } else {
              document.title = route.title;
            }
            return _react2.default.createElement(Page, { route: _extends({}, route, { params: params }), error: context.error });
          })
        };
      };

      for (var _iterator = routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var _ret = _loop();

        switch (_ret) {
          case 'continue':
            continue;

          default:
            if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
        }
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    return error('Page not found', 404);
  }
};