found-relay/es/ReadyStateRenderer.js

Relay integration for found

import _Reflect$construct from "@babel/runtime-corejs3/core-js-stable/reflect/construct";
import _extends from "@babel/runtime-corejs3/helpers/esm/extends";
import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
import _objectWithoutPropertiesLoose from "@babel/runtime-corejs3/helpers/esm/objectWithoutPropertiesLoose";
import _possibleConstructorReturn from "@babel/runtime-corejs3/helpers/esm/possibleConstructorReturn";
import _getPrototypeOf from "@babel/runtime-corejs3/helpers/esm/getPrototypeOf";
import _inheritsLoose from "@babel/runtime-corejs3/helpers/esm/inheritsLoose";

function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(_Reflect$construct(Date, [], function () {})); return true; } catch (e) { return false; } }

import PropTypes from 'prop-types';
import React from 'react';
import { ReactRelayContext } from 'react-relay';
import warning from 'warning';
import QuerySubscription from './QuerySubscription';
import renderElement from './renderElement';
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propTypes = {
  match: PropTypes.shape({
    route: PropTypes.object.isRequired
  }).isRequired,
  Component: PropTypes.elementType,
  isComponentResolved: PropTypes.bool.isRequired,
  hasComponent: PropTypes.bool.isRequired,
  element: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),
  routeChildren: PropTypes.oneOfType([PropTypes.object, PropTypes.element]),
  querySubscription: PropTypes.instanceOf(QuerySubscription).isRequired,
  fetched: PropTypes.bool.isRequired
};

var ReadyStateRenderer = /*#__PURE__*/function (_React$Component) {
  _inheritsLoose(ReadyStateRenderer, _React$Component);

  var _super = _createSuper(ReadyStateRenderer);

  function ReadyStateRenderer(props) {
    var _this;

    _this = _React$Component.call(this, props) || this;

    _this.onUpdate = function () {
      if (!_this.props.fetched) {
        // Ignore subscription updates if our data aren't yet fetched. We'll
        // rerender anyway once fetching finishes.
        return;
      }

      var _this$props = _this.props,
          match = _this$props.match,
          Component = _this$props.Component,
          isComponentResolved = _this$props.isComponentResolved,
          hasComponent = _this$props.hasComponent,
          querySubscription = _this$props.querySubscription;
      var element = renderElement({
        match: match,
        Component: Component,
        isComponentResolved: isComponentResolved,
        hasComponent: hasComponent,
        querySubscription: querySubscription,
        resolving: false
      });

      _this.setState({
        element: element || null
      });
    };

    var _element = props.element,
        _querySubscription = props.querySubscription;
    _this.state = {
      isInitialRender: true,
      element: _element,
      propsElement: _element,
      querySubscription: _querySubscription,
      selectionReference: _querySubscription.retain(),
      onUpdate: _this.onUpdate
    };
    return _this;
  }

  var _proto = ReadyStateRenderer.prototype;

  _proto.componentDidMount = function componentDidMount() {
    this.props.querySubscription.subscribe(this.onUpdate);
  };

  ReadyStateRenderer.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, state) {
    var element = _ref.element,
        querySubscription = _ref.querySubscription;

    if (state.isInitialRender) {
      return {
        isInitialRender: false
      };
    }

    var nextState = null;

    if (element !== state.propsElement) {
      nextState = {
        element: element,
        propsElement: element
      };
    }

    if (querySubscription !== state.querySubscription) {
      state.selectionReference.dispose();
      state.querySubscription.unsubscribe(state.onUpdate);
      nextState = nextState || {};
      nextState.querySubscription = querySubscription;
      nextState.selectionReference = querySubscription.retain();
      querySubscription.subscribe(state.onUpdate);
    }

    return nextState;
  };

  _proto.componentWillUnmount = function componentWillUnmount() {
    this.state.selectionReference.dispose();
    this.props.querySubscription.unsubscribe(this.onUpdate);
  };

  _proto.render = function render() {
    var element = this.state.element;

    if (!element) {
      return element;
    }

    var _this$props2 = this.props,
        _m = _this$props2.match,
        _C = _this$props2.Component,
        _iCR = _this$props2.isComponentResolved,
        _hC = _this$props2.hasComponent,
        _e = _this$props2.element,
        routeChildren = _this$props2.routeChildren,
        querySubscription = _this$props2.querySubscription,
        _f = _this$props2.fetched,
        ownProps = _objectWithoutPropertiesLoose(_this$props2, ["match", "Component", "isComponentResolved", "hasComponent", "element", "routeChildren", "querySubscription", "fetched"]);

    var relayProps = querySubscription.readyState.props;

    if (relayProps) {
      var _context;

      _forEachInstanceProperty(_context = _Object$keys(relayProps)).call(_context, function (relayPropName) {
        // At least on Node v8.x, it's slightly faster to guard the delete here
        // with this hasOwnProperty check.
        if (hasOwnProperty.call(ownProps, relayPropName)) {
          process.env.NODE_ENV !== "production" ? warning(false, 'Ignoring <ReadyStateRenderer> prop `%s` that shadows a Relay prop from its query `%s`. This is most likely due to its parent cloning it and adding extraneous Relay props.', relayPropName, querySubscription.getQueryName()) : void 0;
          delete ownProps[relayPropName];
        }
      });
    }

    return /*#__PURE__*/React.createElement(ReactRelayContext.Provider, {
      value: querySubscription.relayContext
    }, typeof element === 'function' ? React.cloneElement(element(routeChildren), ownProps) : React.cloneElement(element, _extends({}, React.isValidElement(routeChildren) ? {
      children: routeChildren
    } : routeChildren, {}, ownProps)));
  };

  return ReadyStateRenderer;
}(React.Component);

ReadyStateRenderer.propTypes = propTypes;
export default ReadyStateRenderer;