react-compose-context-consumers/dist/index.es.js

Compose React 16.3 ContextConsumers

import React from 'react';

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

var toConsumableArray = function (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 compose() {
  for (var _len = arguments.length, contextConsumers = Array(_len), _key = 0; _key < _len; _key++) {
    contextConsumers[_key] = arguments[_key];
  }

  return function (_React$PureComponent) {
    inherits(Composed, _React$PureComponent);

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

    createClass(Composed, [{
      key: 'render',
      value: function render() {
        var _this2 = this;

        var composeHelper = function composeHelper(remainingContextConsumers) {
          var collectedContexts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

          if (!remainingContextConsumers.length) {
            var _props;

            return (_props = _this2.props).children.apply(_props, toConsumableArray(collectedContexts));
          }

          var _remainingContextCons = toArray(remainingContextConsumers),
              Next = _remainingContextCons[0],
              rest = _remainingContextCons.slice(1);

          return React.createElement(
            Next,
            null,
            function (context) {
              return composeHelper(rest, [].concat(toConsumableArray(collectedContexts), [context]));
            }
          );
        };

        return composeHelper(contextConsumers);
      }
    }]);
    return Composed;
  }(React.PureComponent);
}

function elementsWillChange(nextElements, currentElements) {
  if (nextElements.length !== currentElements.length) {
    return true;
  }

  for (var i = 0; i < currentElements.length; i += 1) {
    if (nextElements[i] !== currentElements[i]) {
      return true;
    }
  }

  return false;
}

var Compose = function (_React$PureComponent) {
  inherits(Compose, _React$PureComponent);

  function Compose() {
    var _ref;

    var _temp, _this, _ret;

    classCallCheck(this, Compose);

    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return _ret = (_temp = (_this = possibleConstructorReturn(this, (_ref = Compose.__proto__ || Object.getPrototypeOf(Compose)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
      sortedContextNames: [],
      sortedContextConsumers: []
    }, _temp), possibleConstructorReturn(_this, _ret);
  }

  createClass(Compose, [{
    key: 'render',
    value: function render() {
      var _this2 = this;

      var Composed = this.state.Composed;
      return React.createElement(
        Composed,
        null,
        function () {
          for (var _len2 = arguments.length, contexts = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            contexts[_key2] = arguments[_key2];
          }

          var contextsMap = {};
          _this2.state.sortedContextNames.forEach(function (k, idx) {
            return contextsMap[k] = contexts[idx];
          });

          return _this2.props.children(contextsMap);
        }
      );
    }
  }], [{
    key: 'getDerivedStateFromProps',
    value: function getDerivedStateFromProps(nextProps, prevState) {
      var children = nextProps.children,
          contextConsumersMap = objectWithoutProperties(nextProps, ['children']);
      // We sort context names to make comparison against previous props simpler.

      var nextSortedContextNames = Object.keys(contextConsumersMap).sort();
      var nextSortedContextConsumers = nextSortedContextNames.map(function (k) {
        return contextConsumersMap[k];
      });

      if (!elementsWillChange(nextSortedContextNames, prevState.sortedContextNames) && !elementsWillChange(nextSortedContextConsumers, prevState.sortedContextConsumers)) {
        return null;
      }

      return {
        sortedContextNames: nextSortedContextNames,
        sortedContextConsumers: nextSortedContextConsumers,
        Composed: compose.apply(undefined, toConsumableArray(nextSortedContextConsumers))
      };
    }
  }]);
  return Compose;
}(React.PureComponent);

export default Compose;
export { compose, Compose };