content: var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
  
  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; };
  
  import invariant from 'invariant';
  import React from 'react';
  
  import deprecateObjectProperties from './deprecateObjectProperties';
  import getRouteParams from './getRouteParams';
  import { isReactChildren } from './RouteUtils';
  import warning from './routerWarning';
  
  var _React$PropTypes = React.PropTypes;
  var array = _React$PropTypes.array;
  var func = _React$PropTypes.func;
  var object = _React$PropTypes.object;
  
  /**
   * A <RouterContext> renders the component tree for a given router state
   * and sets the history object and the current location in context.
   */
  
  var RouterContext = React.createClass({
    displayName: 'RouterContext',
  
  
    propTypes: {
      history: object,
      router: object.isRequired,
      location: object.isRequired,
      routes: array.isRequired,
      params: object.isRequired,
      components: array.isRequired,
      createElement: func.isRequired
    },
  
    getDefaultProps: function getDefaultProps() {
      return {
        createElement: React.createElement
      };
    },
  
  
    childContextTypes: {
      history: object,
      location: object.isRequired,
      router: object.isRequired
    },
  
    getChildContext: function getChildContext() {
      var _props = this.props;
      var router = _props.router;
      var history = _props.history;
      var location = _props.location;
  
      if (!router) {
        process.env.NODE_ENV !== 'production' ? warning(false, '`<RouterContext>` expects a `router` rather than a `history`') : void 0;
  
        router = _extends({}, history, {
          setRouteLeaveHook: history.listenBeforeLeavingRoute
        });
        delete router.listenBeforeLeavingRoute;
      }
  
      if (process.env.NODE_ENV !== 'production') {
        location = deprecateObjectProperties(location, '`context.location` is deprecated, please use a route component\'s `props.location` instead. http://tiny.cc/router-accessinglocation');
      }
  
      return { history: history, location: location, router: router };
    },
    createElement: function createElement(component, props) {
      return component == null ? null : this.props.createElement(component, props);
    },
    render: function render() {
      var _this = this;
  
      var _props2 = this.props;
      var history = _props2.history;
      var location = _props2.location;
      var routes = _props2.routes;
      var params = _props2.params;
      var components = _props2.components;
  
      var element = null;
  
      if (components) {
        element = components.reduceRight(function (element, components, index) {
          if (components == null) return element; // Don't create new children; use the grandchildren.
  
          var route = routes[index];
          var routeParams = getRouteParams(route, params);
          var props = {
            history: history,
            location: location,
            params: params,
            route: route,
            routeParams: routeParams,
            routes: routes
          };
  
          if (isReactChildren(element)) {
            props.children = element;
          } else if (element) {
            for (var prop in element) {
              if (Object.prototype.hasOwnProperty.call(element, prop)) props[prop] = element[prop];
            }
          }
  
          if ((typeof components === 'undefined' ? 'undefined' : _typeof(components)) === 'object') {
            var elements = {};
  
            for (var key in components) {
              if (Object.prototype.hasOwnProperty.call(components, key)) {
                // Pass through the key as a prop to createElement to allow
                // custom createElement functions to know which named component
                // they're rendering, for e.g. matching up to fetched data.
                elements[key] = _this.createElement(components[key], _extends({
                  key: key }, props));
              }
            }
  
            return elements;
          }
  
          return _this.createElement(components, props);
        }, element);
      }
  
      !(element === null || element === false || React.isValidElement(element)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'The root route must render a single element') : invariant(false) : void 0;
  
      return element;
    }
  });
  
  export default RouterContext;