react-relay 15.0.0 → 16.1.0

package/lib/ReactRelayPaginationContainer.js

@@ -1,14 +1,3 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- * @format
- * @oncall relay
- */
-
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
@@ -45,138 +34,6 @@ var _require3 = require('relay-runtime'),
   isScalarAndEqual = _require3.isScalarAndEqual;
 var warning = require("fbjs/lib/warning");
 var FORWARD = 'forward';
-/**
- * Extends the functionality of RelayFragmentContainer by providing a mechanism
- * to load more data from a connection.
- *
- * # Configuring a PaginationContainer
- *
- * PaginationContainer accepts the standard FragmentContainer arguments and an
- * additional `connectionConfig` argument:
- *
- * - `Component`: the component to be wrapped/rendered.
- * - `fragments`: an object whose values are `graphql` fragments. The object
- *   keys determine the prop names by which fragment data is available.
- * - `connectionConfig`: an object that determines how to load more connection
- *   data. Details below.
- *
- * # Loading More Data
- *
- * Use `props.relay.hasMore()` to determine if there are more items to load.
- *
- * ```
- * hasMore(): boolean
- * ```
- *
- * Use `props.relay.isLoading()` to determine if a previous call to `loadMore()`
- * is still pending. This is convenient for avoiding duplicate load calls.
- *
- * ```
- * isLoading(): boolean
- * ```
- *
- * Use `props.relay.loadMore()` to load more items. This will return null if
- * there are no more items to fetch, otherwise it will fetch more items and
- * return a Disposable that can be used to cancel the fetch.
- *
- * `pageSize` should be the number of *additional* items to fetch (not the
- * total).
- *
- * ```
- * loadMore(pageSize: number, callback: ?(error: ?Error) => void): ?Disposable
- * ```
- *
- * A complete example:
- *
- * ```
- * class Foo extends React.Component {
- *   ...
- *   _onEndReached() {
- *     if (!this.props.relay.hasMore() || this.props.relay.isLoading()) {
- *       return;
- *     }
- *     this.props.relay.loadMore(10);
- *   }
- *   ...
- * }
- * ```
- *
- * # Connection Config
- *
- * Here's an example, followed by details of each config property:
- *
- * ```
- * ReactRelayPaginationContainer.createContainer(
- *   Component,
- *   {
- *     user: graphql`fragment FriendsFragment on User {
- *       friends(after: $afterCursor first: $count) @connection {
- *         edges { ... }
- *         pageInfo {
- *           startCursor
- *           endCursor
- *           hasNextPage
- *           hasPreviousPage
- *         }
- *       }
- *     }`,
- *   },
- *   {
- *     direction: 'forward',
- *     getConnectionFromProps(props) {
- *       return props.user && props.user.friends;
- *     },
- *     getFragmentVariables(vars, totalCount) {
- *       // The component presumably wants *all* edges, not just those after
- *       // the cursor, so notice that we don't set $afterCursor here.
- *       return {
- *         ...vars,
- *         count: totalCount,
- *       };
- *     },
- *     getVariables(props, {count, cursor}, fragmentVariables) {
- *       return {
- *         id: props.user.id,
- *         afterCursor: cursor,
- *         count,
- *       },
- *     },
- *     query: graphql`
- *       query FriendsQuery($id: ID!, $afterCursor: ID, $count: Int!) {
- *         node(id: $id) {
- *           ...FriendsFragment
- *         }
- *       }
- *     `,
- *   }
- * );
- * ```
- *
- * ## Config Properties
- *
- * - `direction`: Either "forward" to indicate forward pagination using
- *   after/first, or "backward" to indicate backward pagination using
- *   before/last.
- * - `getConnectionFromProps(props)`: PaginationContainer doesn't magically know
- *   which connection data you mean to fetch more of (a container might fetch
- *   multiple connections, but can only paginate one of them). This function is
- *   given the fragment props only (not full props), and should return the
- *   connection data. See the above example that returns the friends data via
- *   `props.user.friends`.
- * - `getFragmentVariables(previousVars, totalCount)`: Given the previous variables
- *   and the new total number of items, get the variables to use when reading
- *   your fragments. Typically this means setting whatever your local "count"
- *   variable is to the value of `totalCount`. See the example.
- * - `getVariables(props, {count, cursor})`: Get the variables to use when
- *   fetching the pagination `query`. You may determine the root object id from
- *   props (see the example that uses `props.user.id`) and may also set whatever
- *   variables you use for the after/first/before/last calls based on the count
- *   and cursor.
- * - `query`: A query to use when fetching more connection data. This should
- *   typically reference one of the container's fragment (as in the example)
- *   to ensure that all the necessary fields for sub-components are fetched.
- */
-
 function createGetConnectionFromProps(metadata) {
   var path = metadata.path;
   !path ? process.env.NODE_ENV !== "production" ? invariant(false, 'ReactRelayPaginationContainer: Unable to synthesize a ' + 'getConnectionFromProps function.') : invariant(false) : void 0;
@@ -204,9 +61,6 @@ function findConnectionMetadata(fragments) {
   for (var fragmentName in fragments) {
     var fragment = fragments[fragmentName];
     var connectionMetadata = fragment.metadata && fragment.metadata.connection;
-    // HACK: metadata is always set to `undefined` in classic. In modern, even
-    // if empty, it is set to null (never undefined). We use that knowlege to
-    // check if we're dealing with classic or modern
     if (fragment.metadata !== undefined) {
       isRelayModern = true;
     }
@@ -241,8 +95,6 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
   var getFragmentVariables = connectionConfig.getFragmentVariables || createGetFragmentVariables(metadata);
   return _class = /*#__PURE__*/function (_React$Component) {
     (0, _inheritsLoose2["default"])(_class, _React$Component);
-    // $FlowFixMe[missing-local-annot]
-
     function _class(props) {
       var _props$__rootIsQueryR, _this;
       _this = _React$Component.call(this, props) || this;
@@ -346,13 +198,7 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
           this._rerenderIfStoreHasChanged();
         }
       }
-    }
-
-    /**
-     * When new props are received, read data for the new props and subscribe
-     * for updates. Props may be the same in which case previous data and
-     * subscriptions can be reused.
-     */;
+    };
     _proto.UNSAFE_componentWillReceiveProps = function UNSAFE_componentWillReceiveProps(nextProps) {
       var _this2 = this;
       var _nextProps$__rootIsQu;
@@ -362,15 +208,8 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
       var nextIDs = getDataIDsFromObject(fragments, nextProps);
       var prevRootVariables = getRootVariablesForFragments(fragments, this.props);
       var nextRootVariables = getRootVariablesForFragments(fragments, nextProps);
-
-      // If the environment has changed or props point to new records then
-      // previously fetched data and any pending fetches no longer apply:
-      // - Existing references are on the old environment.
-      // - Existing references are based on old variables.
-      // - Pending fetches are for the previous records.
       if (relayContext.environment !== this.state.prevContext.environment || !areEqual(prevRootVariables, nextRootVariables) || !areEqual(prevIDs, nextIDs)) {
         this._cleanup();
-        // Child containers rely on context.relay being mutated (for gDSFP).
         if (RelayFeatureFlags.ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT === true) {
           this._resolver = createFragmentSpecResolver(relayContext, containerName, fragments, nextProps, rootIsQueryRenderer);
         } else {
@@ -399,12 +238,9 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
       this._cleanup();
     };
     _proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
-      // Short-circuit if any Relay-related data has changed
       if (nextState.data !== this.state.data || nextState.relayProp !== this.state.relayProp || nextState.resolverGeneration !== this.state.resolverGeneration) {
         return true;
       }
-      // Otherwise, for convenience short-circuit if all non-Relay props
-      // are scalar and equal
       var keys = Object.keys(nextProps);
       for (var ii = 0; ii < keys.length; ii++) {
         var key = keys[ii];
@@ -431,8 +267,6 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
     };
     _proto._rerenderIfStoreHasChanged = function _rerenderIfStoreHasChanged() {
       var data = this.state.data;
-      // External values could change between render and commit.
-      // Check for this case, even though it requires an extra store read.
       var maybeNewData = this._resolver.resolve();
       if (data !== maybeNewData) {
         this.setState({
@@ -443,26 +277,14 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
     _proto._subscribeToNewResolverAndRerenderIfStoreHasChanged = function _subscribeToNewResolverAndRerenderIfStoreHasChanged() {
       var data = this.state.data;
       var maybeNewData = this._resolver.resolve();
-
-      // Event listeners are only safe to add during the commit phase,
-      // So they won't leak if render is interrupted or errors.
       this._resolver.setCallback(this.props, this._handleFragmentDataUpdate);
-
-      // External values could change between render and commit.
-      // Check for this case, even though it requires an extra store read.
       if (data !== maybeNewData) {
         this.setState({
           data: maybeNewData
         });
       }
-    }
-
-    /**
-     * Render new data for the existing props/context.
-     */;
+    };
     _proto._getConnectionData = function _getConnectionData() {
-      // Extract connection data and verify there are more edges to fetch
-      // eslint-disable-next-line no-unused-vars
       var _this$props = this.props,
         _ = _this$props.componentRef,
         restProps = (0, _objectWithoutPropertiesLoose2["default"])(_this$props, _excluded);
@@ -549,16 +371,6 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
         var prevData = _this3._resolver.resolve();
         _this3._resolver.setVariables(getFragmentVariables(fragmentVariables, paginatingVariables.totalCount), operation.request.node);
         var nextData = _this3._resolver.resolve();
-
-        // Workaround slightly different handling for connection in different
-        // core implementations:
-        // - Classic core requires the count to be explicitly incremented
-        // - Modern core automatically appends new items, updating the count
-        //   isn't required to see new data.
-        //
-        // `setState` is only required if changing the variables would change the
-        // resolved data.
-        // TODO #14894725: remove PaginationContainer equal check
         if (!areEqual(prevData, nextData)) {
           _this3.setState({
             data: nextData,
@@ -584,13 +396,11 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
       }).mergeMap(function (payload) {
         return Observable.create(function (sink) {
           onNext(payload, function () {
-            sink.next(); // pass void to public observer's `next`
+            sink.next();
             sink.complete();
           });
         });
-      })
-      // use do instead of finally so that observer's `complete` fires after cleanup
-      ["do"]({
+      })["do"]({
         error: cleanup,
         complete: cleanup,
         unsubscribe: cleanup
@@ -610,12 +420,8 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
       if (this._queryFetcher) {
         this._queryFetcher.dispose();
       }
-    }
-
-    // $FlowFixMe[missing-local-annot]
-    ;
+    };
     _proto.render = function render() {
-      // eslint-disable-next-line no-unused-vars
       var _this$props3 = this.props,
         componentRef = _this$props3.componentRef,
         __relayContext = _this$props3.__relayContext,
@@ -631,16 +437,7 @@ function createContainerWithFragments(Component, fragments, connectionConfig) {
     return _class;
   }(React.Component), (0, _defineProperty2["default"])(_class, "displayName", containerName), _class;
 }
-
-/**
- * Wrap the basic `createContainer()` function with logic to adapt to the
- * `context.relay.environment` in which it is rendered. Specifically, the
- * extraction of the environment-specific version of fragments in the
- * `fragmentSpec` is memoized once per environment, rather than once per
- * instance of the container constructed/rendered.
- */
 function createContainer(Component, fragmentSpec, connectionConfig) {
-  // $FlowFixMe[incompatible-return]
   return buildReactRelayContainer(Component, fragmentSpec, function (ComponentClass, fragments) {
     return createContainerWithFragments(ComponentClass, fragments, connectionConfig);
   });

package/lib/ReactRelayQueryFetcher.js

@@ -1,14 +1,3 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- * @format
- * @oncall relay
- */
-
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
@@ -45,7 +34,6 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
   };
   _proto.getFetchResult = function getFetchResult() {
     if (this._didFetchFinish) {
-      // We don't reset '_didFetchFinish' because another callback may be set
       if (this._error != null) {
         return {
           error: this._error
@@ -67,8 +55,6 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
       preservePreviousReferences = _ref$preservePrevious === void 0 ? false : _ref$preservePrevious;
     var reference = environment.retain(operation);
     var error = function error() {
-      // We may have partially fulfilled the request, so let the next request
-      // or the unmount dispose of the references.
       _this._selectionReferences = _this._selectionReferences.concat(reference);
     };
     var complete = function complete() {
@@ -78,8 +64,6 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
       _this._selectionReferences = _this._selectionReferences.concat(reference);
     };
     var unsubscribe = function unsubscribe() {
-      // Let the next request or the unmount code dispose of the references.
-      // We may have partially fulfilled the request.
       _this._selectionReferences = _this._selectionReferences.concat(reference);
     };
     if (!isRelayModernEnvironment(environment)) {
@@ -100,12 +84,9 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
   _proto.setOnDataChange = function setOnDataChange(onDataChange) {
     !this._fetchOptions ? process.env.NODE_ENV !== "production" ? invariant(false, 'ReactRelayQueryFetcher: `setOnDataChange` should have been called after having called `fetch`') : invariant(false) : void 0;
     if (typeof onDataChange === 'function') {
-      // Mutate the most recent fetchOptions in place,
-      // So that in-progress requests can access the updated callback.
       this._fetchOptions.onDataChangeCallbacks = this._fetchOptions.onDataChangeCallbacks || [];
       this._fetchOptions.onDataChangeCallbacks.push(onDataChange);
       if (this._didFetchFinish) {
-        // We don't reset '_didFetchFinish' because another callback may be set
         if (this._error != null) {
           onDataChange({
             error: this._error
@@ -117,17 +98,7 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
         }
       }
     }
-  }
-
-  /**
-   * `fetch` fetches the data for the given operation.
-   * If a result is immediately available synchronously, it will be synchronously
-   * returned by this function.
-   *
-   * Otherwise, the fetched result will be communicated via the `onDataChange` callback.
-   * `onDataChange` will be called with the first result (**if it wasn't returned synchronously**),
-   * and then subsequently whenever the data changes.
-   */;
+  };
   _proto.fetch = function fetch(fetchOptions, cacheConfigOverride) {
     var _this2 = this;
     var environment = fetchOptions.environment,
@@ -143,7 +114,6 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
       operation: operation
     };
     if (onDataChange && this._fetchOptions.onDataChangeCallbacks.indexOf(onDataChange) === -1) {
-      // $FlowFixMe[incompatible-use]
       this._fetchOptions.onDataChangeCallbacks.push(onDataChange);
     }
     var operationOverride = cacheConfigOverride ? createOperationDescriptor(operation.request.node, operation.request.variables, cacheConfigOverride) : operation;
@@ -154,27 +124,17 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
       _this2._pendingRequest = null;
     }).subscribe({
       next: function next() {
-        // If we received a response,
-        // Make a note that to notify the callback when it's later added.
         _this2._didFetchFinish = true;
         _this2._error = null;
-
-        // Only notify of the first result if `next` is being called **asynchronously**
-        // (i.e. after `fetch` has returned).
         _this2._onQueryDataAvailable({
           notifyFirstResult: fetchHasReturned
         });
       },
       error: function error(err) {
-        // If we received a response when we didn't have a change callback,
-        // Make a note that to notify the callback when it's later added.
         _this2._didFetchFinish = true;
         _this2._error = err;
         _this2._snapshot = null;
         var onDataChangeCallbacks = _this2._fetchOptions && _this2._fetchOptions.onDataChangeCallbacks;
-
-        // Only notify of error if `error` is being called **asynchronously**
-        // (i.e. after `fetch` has returned).
         if (fetchHasReturned) {
           if (onDataChangeCallbacks) {
             onDataChangeCallbacks.forEach(function (onDataChange) {
@@ -204,7 +164,7 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
     return this.fetch({
       environment: this._fetchOptions.environment,
       operation: this._fetchOptions.operation,
-      onDataChange: null // If there are onDataChangeCallbacks they will be reused
+      onDataChange: null
     }, cacheConfigOverride);
   };
   _proto.dispose = function dispose() {
@@ -214,8 +174,6 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
   _proto.disposeRequest = function disposeRequest() {
     this._error = null;
     this._snapshot = null;
-
-    // order is important, dispose of pendingFetch before selectionReferences
     if (this._pendingRequest) {
       this._pendingRequest.dispose();
     }
@@ -247,18 +205,11 @@ var ReactRelayQueryFetcher = /*#__PURE__*/function () {
       environment = _this$_fetchOptions.environment,
       onDataChangeCallbacks = _this$_fetchOptions.onDataChangeCallbacks,
       operation = _this$_fetchOptions.operation;
-
-    // `_onQueryDataAvailable` can be called synchronously the first time and can be called
-    // multiple times by network layers that support data subscriptions.
-    // Wait until the first payload to call `onDataChange` and subscribe for data updates.
     if (this._snapshot) {
       return;
     }
     this._snapshot = environment.lookup(operation.fragment);
-
-    // Subscribe to changes in the data of the root fragment
     this._rootSubscription = environment.subscribe(this._snapshot, function (snapshot) {
-      // Read from this._fetchOptions in case onDataChange() was lazily added.
       if (_this3._fetchOptions != null) {
         var maybeNewOnDataChangeCallbacks = _this3._fetchOptions.onDataChangeCallbacks;
         if (Array.isArray(maybeNewOnDataChangeCallbacks)) {

package/lib/ReactRelayQueryRenderer.js

@@ -1,14 +1,3 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- * @format
- * @oncall relay
- */
-
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
@@ -22,42 +11,18 @@ var ReactRelayQueryRendererContext = require('./ReactRelayQueryRendererContext')
 var areEqual = require("fbjs/lib/areEqual");
 var React = require('react');
 var _require = require('relay-runtime'),
-  RelayFeatureFlags = _require.RelayFeatureFlags;
-var _require2 = require('relay-runtime'),
-  createOperationDescriptor = _require2.createOperationDescriptor,
-  deepFreeze = _require2.deepFreeze,
-  getRequest = _require2.getRequest;
-/**
- * React may double-fire the constructor, and we call 'fetch' in the
- * constructor. If a request is already in flight from a previous call to the
- * constructor, just reuse the query fetcher and wait for the response.
- */
+  createOperationDescriptor = _require.createOperationDescriptor,
+  deepFreeze = _require.deepFreeze,
+  getRequest = _require.getRequest;
 var requestCache = {};
 var queryRendererContext = {
   rootIsQueryRenderer: true
 };
-/**
- * @public
- *
- * Orchestrates fetching and rendering data for a single view or view hierarchy:
- * - Fetches the query/variables using the given network implementation.
- * - Normalizes the response(s) to that query, publishing them to the given
- *   store.
- * - Renders the pending/fail/success states with the provided render function.
- * - Subscribes for updates to the root data and re-renders with any changes.
- */
 var ReactRelayQueryRenderer = /*#__PURE__*/function (_React$Component) {
   (0, _inheritsLoose2["default"])(ReactRelayQueryRenderer, _React$Component);
   function ReactRelayQueryRenderer(props) {
     var _this;
     _this = _React$Component.call(this, props) || this;
-
-    // Callbacks are attached to the current instance and shared with static
-    // lifecyles by bundling with state. This is okay to do because the
-    // callbacks don't change in reaction to props. However we should not
-    // "leak" them before mounting (since we would be unable to clean up). For
-    // that reason, we define them as null initially and fill them in after
-    // mounting to avoid leaking memory.
     (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_handleDataChange", function (params) {
       var error = params.error == null ? null : params.error;
       var snapshot = params.snapshot == null ? null : params.snapshot;
@@ -66,8 +31,6 @@ var ReactRelayQueryRenderer = /*#__PURE__*/function (_React$Component) {
         if (prevRequestCacheKey) {
           delete requestCache[prevRequestCacheKey];
         }
-
-        // Don't update state if nothing has changed.
         if (snapshot === prevState.snapshot && error === prevState.error) {
           return null;
         }
@@ -112,38 +75,13 @@ var ReactRelayQueryRenderer = /*#__PURE__*/function (_React$Component) {
   _proto.componentDidMount = function componentDidMount() {
     var _this2 = this;
     if (this._maybeHiddenOrFastRefresh === true) {
-      // This block only runs if the component has previously "unmounted"
-      // due to it being hidden by the Offscreen API, or during fast refresh.
-      // At this point, the current cached resource will have been disposed
-      // by the previous cleanup, so instead of attempting to
-      // do our regular commit setup, so that the query is re-evaluated
-      // (and potentially cause a refetch).
       this._maybeHiddenOrFastRefresh = false;
-      // eslint-disable-next-line react/no-did-mount-set-state
       this.setState(function (prevState) {
         var newState = resetQueryStateForUpdate(_this2.props, prevState);
         var requestCacheKey = newState.requestCacheKey,
           queryFetcher = newState.queryFetcher;
         if (requestCacheKey != null && requestCache[requestCacheKey] != null) {
-          if (RelayFeatureFlags.ENABLE_QUERY_RENDERER_SET_STATE_PREVENTION) {
-            var fetchResult = queryFetcher.getFetchResult();
-            if (fetchResult != null) {
-              var _fetchResult$snapshot, _fetchResult$error;
-              var snapshot = (_fetchResult$snapshot = fetchResult.snapshot) !== null && _fetchResult$snapshot !== void 0 ? _fetchResult$snapshot : null;
-              var error = (_fetchResult$error = fetchResult.error) !== null && _fetchResult$error !== void 0 ? _fetchResult$error : null;
-              var prevRequestCacheKey = prevState.requestCacheKey;
-              if (prevRequestCacheKey != null) {
-                delete requestCache[prevRequestCacheKey];
-              }
-              newState.renderProps = getRenderProps(error, snapshot, queryFetcher, prevState.retryCallbacks);
-              newState.snapshot = snapshot;
-              newState.requestCacheKey = null;
-            } else {
-              queryFetcher.setOnDataChange(_this2._handleDataChange);
-            }
-          } else {
-            queryFetcher.setOnDataChange(_this2._handleDataChange);
-          }
+          queryFetcher.setOnDataChange(_this2._handleDataChange);
         }
         return newState;
       });
@@ -153,7 +91,6 @@ var ReactRelayQueryRenderer = /*#__PURE__*/function (_React$Component) {
       retryCallbacks = _this$state.retryCallbacks,
       queryFetcher = _this$state.queryFetcher,
       requestCacheKey = _this$state.requestCacheKey;
-    // We don't need to cache the request after the component commits
     if (requestCacheKey) {
       delete requestCache[requestCacheKey];
     }
@@ -170,21 +107,16 @@ var ReactRelayQueryRenderer = /*#__PURE__*/function (_React$Component) {
         };
       });
     };
-
-    // Re-initialize the ReactRelayQueryFetcher with callbacks.
-    // If data has changed since constructions, this will re-render.
     if (this.props.query) {
       queryFetcher.setOnDataChange(this._handleDataChange);
     }
   };
   _proto.componentDidUpdate = function componentDidUpdate(_prevProps, prevState) {
-    // We don't need to cache the request after the component commits
     var _this$state2 = this.state,
       queryFetcher = _this$state2.queryFetcher,
       requestCacheKey = _this$state2.requestCacheKey;
     if (requestCacheKey) {
       delete requestCache[requestCacheKey];
-      // HACK
       delete this.state.requestCacheKey;
     }
     if (this.props.query && queryFetcher !== prevState.queryFetcher) {
@@ -202,9 +134,6 @@ var ReactRelayQueryRenderer = /*#__PURE__*/function (_React$Component) {
     var _this$state3 = this.state,
       renderProps = _this$state3.renderProps,
       relayContext = _this$state3.relayContext;
-    // Note that the root fragment results in `renderProps.props` is already
-    // frozen by the store; this call is to freeze the renderProps object and
-    // error property if set.
     if (process.env.NODE_ENV !== "production") {
       deepFreeze(renderProps);
     }
@@ -220,7 +149,6 @@ function getLoadingRenderProps() {
   return {
     error: null,
     props: null,
-    // `props: null` indicates that the data is being fetched (i.e. loading)
     retry: null
   };
 }
@@ -228,7 +156,6 @@ function getEmptyRenderProps() {
   return {
     error: null,
     props: {},
-    // `props: {}` indicates no data available
     retry: null
   };
 }
@@ -243,8 +170,6 @@ function getRenderProps(error, snapshot, queryFetcher, retryCallbacks) {
           snapshot: syncSnapshot
         });
       } else if (error && typeof retryCallbacks.handleRetryAfterError === 'function') {
-        // If retrying after an error and no synchronous result available,
-        // reset the render props
         retryCallbacks.handleRetryAfterError(error);
       }
     }
@@ -273,12 +198,8 @@ function resetQueryStateForUpdate(props, prevState) {
     prevPropsEnvironment: props.environment,
     prevPropsVariables: props.variables,
     queryFetcher: queryFetcher
-  }, fetchQueryAndComputeStateFromProps(props, queryFetcher, prevState.retryCallbacks
-  // passing no requestCacheKey will cause it to be recalculated internally
-  // and we want the updated requestCacheKey, since variables may have changed
-  ));
+  }, fetchQueryAndComputeStateFromProps(props, queryFetcher, prevState.retryCallbacks));
 }
-
 function fetchQueryAndComputeStateFromProps(props, queryFetcher, retryCallbacks, requestCacheKey) {
   var environment = props.environment,
     query = props.query,
@@ -292,11 +213,8 @@ function fetchQueryAndComputeStateFromProps(props, queryFetcher, retryCallbacks,
       environment: genericEnvironment
     };
     if (typeof requestCacheKey === 'string' && requestCache[requestCacheKey]) {
-      // This same request is already in flight.
-
       var snapshot = requestCache[requestCacheKey].snapshot;
       if (snapshot) {
-        // Use the cached response
         return {
           error: null,
           relayContext: relayContext,
@@ -305,7 +223,6 @@ function fetchQueryAndComputeStateFromProps(props, queryFetcher, retryCallbacks,
           requestCacheKey: requestCacheKey
         };
       } else {
-        // Render loading state
         return {
           error: null,
           relayContext: relayContext,
@@ -322,11 +239,7 @@ function fetchQueryAndComputeStateFromProps(props, queryFetcher, retryCallbacks,
         onDataChange: null,
         operation: operation
       });
-
-      // Use network data first, since it may be fresher
       var _snapshot = querySnapshot || storeSnapshot;
-
-      // cache the request to avoid duplicate requests
       requestCacheKey = requestCacheKey || getRequestCacheKey(request.params, props.variables);
       requestCache[requestCacheKey] = {
         queryFetcher: queryFetcher,
@@ -366,9 +279,8 @@ function fetchQueryAndComputeStateFromProps(props, queryFetcher, retryCallbacks,
       error: null,
       relayContext: _relayContext,
       renderProps: getEmptyRenderProps(),
-      requestCacheKey: null // if there is an error, don't cache request
+      requestCacheKey: null
     };
   }
 }
-
 module.exports = ReactRelayQueryRenderer;