react-context-component/dist/react-context-component.js

This is a React component that lets you add things in the context. Put simply, the [context feature](https://facebook.github.io/react/docs/context.html) basically lets you to pass some data through all nodes in the components tree.

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('prop-types')) :
	typeof define === 'function' && define.amd ? define(['exports', 'react', 'prop-types'], factory) :
	(factory((global.ReactWidth = {}),global.React,global.propTypes));
}(this, (function (exports,React,propTypes) { 'use strict';

var React__default = 'default' in React ? React['default'] : React;
propTypes = propTypes && propTypes.hasOwnProperty('default') ? propTypes['default'] : propTypes;

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

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 inherits = function (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 objectWithoutProperties = function (obj, keys) {
  var target = {};

  for (var i in obj) {
    if (keys.indexOf(i) >= 0) continue;
    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
    target[i] = obj[i];
  }

  return target;
};

var possibleConstructorReturn = function (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;
};

var ContextProvider = function (_Component) {
  inherits(ContextProvider, _Component);

  function ContextProvider() {
    classCallCheck(this, ContextProvider);
    return possibleConstructorReturn(this, (ContextProvider.__proto__ || Object.getPrototypeOf(ContextProvider)).apply(this, arguments));
  }

  createClass(ContextProvider, [{
    key: 'getChildContext',
    value: function getChildContext() {
      var _props = this.props,
          children = _props.children,
          rest = objectWithoutProperties(_props, ['children']);

      return rest;
    }
  }, {
    key: 'render',
    value: function render() {
      return this.props.children;
    }
  }]);
  return ContextProvider;
}(React.Component);

var Context$1 = function (_Component2) {
  inherits(Context, _Component2);

  function Context(props) {
    classCallCheck(this, Context);

    var _this2 = possibleConstructorReturn(this, (Context.__proto__ || Object.getPrototypeOf(Context)).call(this, props));

    var children = props.children,
        rest = objectWithoutProperties(props, ['children']);

    var contextTypes = Object.keys(rest).reduce(function (acc, current) {
      acc[current] = function () {};
      return acc;
    }, {});
    ContextProvider.childContextTypes = contextTypes;
    return _this2;
  }

  createClass(Context, [{
    key: 'render',
    value: function render() {
      return React__default.createElement(ContextProvider, this.props);
    }
  }]);
  return Context;
}(React.Component);

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

  var contextTypeKeys = Object.keys(contextTypes);

  return function (Component$$1) {
    var WithContext = function WithContext(props, context) {
      var mapContextToProps = contextTypeKeys.reduce(function (acc, key) {
        acc[key] = context[key];
        return acc;
      }, {});

      return React__default.createElement(Component$$1, Object.assign({}, props, mapContextToProps));
    };

    WithContext.contextTypes = contextTypes;

    return WithContext;
  };
};

exports.withContext = withContext;
exports['default'] = Context$1;

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

})));