react-redux-provide/lib/install.js

Build your UI with React. Manage application state with Redux providers. Persist and share application state with replication. Use pure functions everywhere.

'use strict';

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

var _provide = require('./provide');

var _provide2 = _interopRequireDefault(_provide);

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

var createElement = _react2.default.createElement;

_react2.default.createElement = function (ComponentClass, props) {
  for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
    args[_key - 2] = arguments[_key];
  }

  if (typeof ComponentClass === 'string') {
    if (props && (typeof props === 'undefined' ? 'undefined' : _typeof(props)) === 'object') {
      delete props.__wrapper;
      delete props.__provided;
    }
    return createElement.apply(this, arguments);
  }

  if (props && props.__provided || ComponentClass && ComponentClass.__provide === false) {
    return createElement.apply(this, arguments);
  }

  if (props && typeof props.component === 'function') {
    props.component = (0, _provide2.default)(props.component);
  }

  if (ComponentClass && !ComponentClass.Provide) {
    ComponentClass.Provide = (0, _provide2.default)(ComponentClass);

    if (process.env.NODE_ENV !== 'production') {
      if (typeof window !== 'undefined' && window.__reactComponentProxies) {
        var _loop = function _loop(key) {
          var proxy = window.__reactComponentProxies[key];
          var update = proxy.update;


          if (!proxy.__provided) {
            proxy.__provided = true;
            proxy.update = function () {
              var instances = update.apply(this, arguments);

              var _iteratorNormalCompletion = true;
              var _didIteratorError = false;
              var _iteratorError = undefined;

              try {
                for (var _iterator = instances[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                  var instance = _step.value;

                  var wrapper = instance.componentProps || !instance.props.__wrapper ? instance : instance.props.__wrapper;
                  var _props = wrapper.props,
                      context = wrapper.context;


                  wrapper.reinitialize(_props, context);
                }
              } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
              } finally {
                try {
                  if (!_iteratorNormalCompletion && _iterator.return) {
                    _iterator.return();
                  }
                } finally {
                  if (_didIteratorError) {
                    throw _iteratorError;
                  }
                }
              }

              return instances;
            };
          }
        };

        for (var key in window.__reactComponentProxies) {
          _loop(key);
        }
      }
    }
  }

  props = props || {};
  props.__provided = true;

  if (props.child && props.child['$$typeof'] && props.child.props) {
    Object.assign(props, props.child.props);
  }

  return createElement.call.apply(createElement, [this, ComponentClass && ComponentClass.Provide || ComponentClass, props].concat(args));
};