react-relay 14.1.0 → 15.0.0

package/lib/ReactRelayRefetchContainer.js

@@ -6,54 +6,38 @@
  *
  * 
  * @format
+ * @oncall relay
  */
+
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
-
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-
 var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
-
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
 var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
-
 var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _excluded = ["componentRef", "__relayContext", "__rootIsQueryRenderer"];
-
 var buildReactRelayContainer = require('./buildReactRelayContainer');
-
 var getRootVariablesForFragments = require('./getRootVariablesForFragments');
-
 var _require = require('./ReactRelayContainerUtils'),
-    getContainerName = _require.getContainerName;
-
+  getContainerName = _require.getContainerName;
 var ReactRelayContext = require('./ReactRelayContext');
-
 var ReactRelayQueryFetcher = require('./ReactRelayQueryFetcher');
-
 var _require2 = require('./RelayContext'),
-    assertRelayContext = _require2.assertRelayContext;
-
+  assertRelayContext = _require2.assertRelayContext;
 var areEqual = require("fbjs/lib/areEqual");
-
 var React = require('react');
-
 var _require3 = require('relay-runtime'),
-    Observable = _require3.Observable,
-    createFragmentSpecResolver = _require3.createFragmentSpecResolver,
-    createOperationDescriptor = _require3.createOperationDescriptor,
-    getDataIDsFromObject = _require3.getDataIDsFromObject,
-    getRequest = _require3.getRequest,
-    getVariablesFromObject = _require3.getVariablesFromObject,
-    isScalarAndEqual = _require3.isScalarAndEqual;
-
+  Observable = _require3.Observable,
+  createFragmentSpecResolver = _require3.createFragmentSpecResolver,
+  createOperationDescriptor = _require3.createOperationDescriptor,
+  getDataIDsFromObject = _require3.getDataIDsFromObject,
+  getRequest = _require3.getRequest,
+  getVariablesFromObject = _require3.getVariablesFromObject,
+  isScalarAndEqual = _require3.isScalarAndEqual;
 var warning = require("fbjs/lib/warning");
-
 /**
  * Composes a React component class, returning a new class that intercepts
  * props, resolving them with the provided fragments and subscribing for
@@ -61,20 +45,19 @@ var warning = require("fbjs/lib/warning");
  */
 function createContainerWithFragments(Component, fragments, taggedNode) {
   var _class;
-
   var containerName = getContainerName(Component);
   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;
       (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_handleFragmentDataUpdate", function () {
         var resolverFromThisUpdate = _this.state.resolver;
-
         _this.setState(function (updatedState) {
-          return (// If this event belongs to the current data source, update.
+          return (
+            // If this event belongs to the current data source, update.
             // Otherwise we should ignore it.
             resolverFromThisUpdate === updatedState.resolver ? {
               data: updatedState.resolver.resolve()
@@ -89,10 +72,8 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
             dispose: function dispose() {}
           };
         }
-
         var _assertRelayContext = assertRelayContext(_this.props.__relayContext),
-            environment = _assertRelayContext.environment;
-
+          environment = _assertRelayContext.environment;
         var rootVariables = getRootVariablesForFragments(fragments, _this.props);
         var fetchVariables = typeof refetchVariables === 'function' ? refetchVariables(_this._getFragmentVariables()) : refetchVariables;
         fetchVariables = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, rootVariables), fetchVariables);
@@ -100,11 +81,9 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
         var cacheConfig = options ? {
           force: !!options.force
         } : undefined;
-
         if (cacheConfig != null && (options === null || options === void 0 ? void 0 : options.metadata) != null) {
           cacheConfig.metadata = options === null || options === void 0 ? void 0 : options.metadata;
         }
-
         var observer = typeof observerOrCallback === 'function' ? {
           // callback is not exectued on complete or unsubscribe
           // for backward compatibility
@@ -112,20 +91,20 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
           error: observerOrCallback
         } : observerOrCallback || {};
         var query = getRequest(taggedNode);
-        var operation = createOperationDescriptor(query, fetchVariables, cacheConfig); // TODO: T26288752 find a better way
+        var operation = createOperationDescriptor(query, fetchVariables, cacheConfig);
 
-        _this.state.localVariables = fetchVariables; // Cancel any previously running refetch.
+        // TODO: T26288752 find a better way
+        _this.state.localVariables = fetchVariables;
 
-        _this._refetchSubscription && _this._refetchSubscription.unsubscribe(); // Declare refetchSubscription before assigning it in .start(), since
-        // synchronous completion may call callbacks .subscribe() returns.
+        // Cancel any previously running refetch.
+        _this._refetchSubscription && _this._refetchSubscription.unsubscribe();
 
+        // Declare refetchSubscription before assigning it in .start(), since
+        // synchronous completion may call callbacks .subscribe() returns.
         var refetchSubscription;
-
         var storeSnapshot = _this._getQueryFetcher().lookupInStore(environment, operation, options === null || options === void 0 ? void 0 : options.fetchPolicy);
-
         if (storeSnapshot != null) {
           _this.state.resolver.setVariables(fragmentVariables, operation.request.node);
-
           _this.setState(function (latestState) {
             return {
               data: latestState.resolver.resolve(),
@@ -137,12 +116,10 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
             observer.next && observer.next();
             observer.complete && observer.complete();
           });
-
           return {
             dispose: function dispose() {}
           };
         }
-
         _this._getQueryFetcher().execute({
           environment: environment,
           operation: operation,
@@ -150,7 +127,6 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
           preservePreviousReferences: true
         }).mergeMap(function (response) {
           _this.state.resolver.setVariables(fragmentVariables, operation.request.node);
-
           return Observable.create(function (sink) {
             return _this.setState(function (latestState) {
               return {
@@ -176,7 +152,6 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
             observer.start && observer.start(subscription);
           }
         }));
-
         return {
           dispose: function dispose() {
             refetchSubscription && refetchSubscription.unsubscribe();
@@ -185,11 +160,11 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
       });
       var relayContext = assertRelayContext(props.__relayContext);
       var rootIsQueryRenderer = (_props$__rootIsQueryR = props.__rootIsQueryRenderer) !== null && _props$__rootIsQueryR !== void 0 ? _props$__rootIsQueryR : false;
-      _this._refetchSubscription = null; // Do not provide a subscription/callback here.
+      _this._refetchSubscription = null;
+      // Do not provide a subscription/callback here.
       // It is possible for this render to be interrupted or aborted,
       // In which case the subscription would cause a leak.
       // We will add the subscription in componentDidMount().
-
       var resolver = createFragmentSpecResolver(relayContext, containerName, fragments, props, rootIsQueryRenderer);
       _this.state = {
         data: resolver.resolve(),
@@ -203,15 +178,11 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
       _this._isUnmounted = false;
       return _this;
     }
-
     var _proto = _class.prototype;
-
     _proto.componentDidMount = function componentDidMount() {
       this._isUnmounted = false;
-
       this._subscribeToNewResolverAndRerenderIfStoreHasChanged();
     };
-
     _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
       // If the environment has changed or props point to new records then
       // previously fetched data and any pending fetches no longer apply:
@@ -222,21 +193,18 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
         prevState.resolver.dispose();
         this._queryFetcher && this._queryFetcher.dispose();
         this._refetchSubscription && this._refetchSubscription.unsubscribe();
-
         this._subscribeToNewResolverAndRerenderIfStoreHasChanged();
       } else {
         this._rerenderIfStoreHasChanged();
       }
     }
+
     /**
      * When new props are received, read data for the new props and add it to
      * state. Props may be the same in which case previous data can be reused.
-     */
-    ;
-
+     */;
     _class.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
       var _nextProps$__rootIsQu;
-
       // Any props change could impact the query, so we mirror props in state.
       // This is an unusual pattern, but necessary for this container usecase.
       var prevProps = prevState.prevProps;
@@ -246,12 +214,13 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
       var nextIDs = getDataIDsFromObject(fragments, nextProps);
       var prevRootVariables = getRootVariablesForFragments(fragments, prevProps);
       var nextRootVariables = getRootVariablesForFragments(fragments, nextProps);
-      var resolver = prevState.resolver; // If the environment has changed or props point to new records then
+      var resolver = prevState.resolver;
+
+      // 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 (prevState.prevPropsContext.environment !== relayContext.environment || !areEqual(prevRootVariables, nextRootVariables) || !areEqual(prevIDs, nextIDs)) {
         // Do not provide a subscription/callback here.
         // It is possible for this render to be interrupted or aborted,
@@ -270,39 +239,31 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
       } else if (!prevState.localVariables) {
         resolver.setProps(nextProps);
       }
-
       var data = resolver.resolve();
-
       if (data !== prevState.data) {
         return {
           data: data,
           prevProps: nextProps
         };
       }
-
       return null;
     };
-
     _proto.componentWillUnmount = function componentWillUnmount() {
       this._isUnmounted = true;
       this.state.resolver.dispose();
       this._queryFetcher && this._queryFetcher.dispose();
       this._refetchSubscription && this._refetchSubscription.unsubscribe();
     };
-
     _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) {
         return true;
-      } // Otherwise, for convenience short-circuit if all non-Relay props
+      }
+      // 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];
-
         if (key === '__relayContext') {
           if (this.state.prevPropsContext.environment !== nextState.prevPropsContext.environment) {
             return true;
@@ -313,67 +274,63 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
           }
         }
       }
-
       return false;
     };
-
     _proto._rerenderIfStoreHasChanged = function _rerenderIfStoreHasChanged() {
       var _this$state = this.state,
-          data = _this$state.data,
-          resolver = _this$state.resolver; // External values could change between render and commit.
+        data = _this$state.data,
+        resolver = _this$state.resolver;
+      // External values could change between render and commit.
       // Check for this case, even though it requires an extra store read.
-
       var maybeNewData = resolver.resolve();
-
       if (data !== maybeNewData) {
         this.setState({
           data: maybeNewData
         });
       }
     };
-
     _proto._subscribeToNewResolverAndRerenderIfStoreHasChanged = function _subscribeToNewResolverAndRerenderIfStoreHasChanged() {
       var _this$state2 = this.state,
-          data = _this$state2.data,
-          resolver = _this$state2.resolver;
-      var maybeNewData = resolver.resolve(); // Event listeners are only safe to add during the commit phase,
+        data = _this$state2.data,
+        resolver = _this$state2.resolver;
+      var maybeNewData = resolver.resolve();
+
+      // Event listeners are only safe to add during the commit phase,
       // So they won't leak if render is interrupted or errors.
+      resolver.setCallback(this.props, this._handleFragmentDataUpdate);
 
-      resolver.setCallback(this.props, this._handleFragmentDataUpdate); // External values could change between render and commit.
+      // 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._getFragmentVariables = function _getFragmentVariables() {
       return getVariablesFromObject(fragments, this.props);
     };
-
     _proto._getQueryFetcher = function _getQueryFetcher() {
       if (!this._queryFetcher) {
         this._queryFetcher = new ReactRelayQueryFetcher();
       }
-
       return this._queryFetcher;
     };
-
+    // $FlowFixMe[missing-local-annot]
     _proto.render = function render() {
+      // eslint-disable-next-line no-unused-vars
       var _this$props = this.props,
-          componentRef = _this$props.componentRef,
-          __relayContext = _this$props.__relayContext,
-          __rootIsQueryRenderer = _this$props.__rootIsQueryRenderer,
-          props = (0, _objectWithoutPropertiesLoose2["default"])(_this$props, _excluded);
+        componentRef = _this$props.componentRef,
+        __relayContext = _this$props.__relayContext,
+        __rootIsQueryRenderer = _this$props.__rootIsQueryRenderer,
+        props = (0, _objectWithoutPropertiesLoose2["default"])(_this$props, _excluded);
       var _this$state3 = this.state,
-          relayProp = _this$state3.relayProp,
-          contextForChildren = _this$state3.contextForChildren;
+        relayProp = _this$state3.relayProp,
+        contextForChildren = _this$state3.contextForChildren;
       return /*#__PURE__*/React.createElement(ReactRelayContext.Provider, {
         value: contextForChildren
       }, /*#__PURE__*/React.createElement(Component, (0, _extends2["default"])({}, props, this.state.data, {
@@ -381,17 +338,16 @@ function createContainerWithFragments(Component, fragments, taggedNode) {
         relay: relayProp
       })));
     };
-
     return _class;
   }(React.Component), (0, _defineProperty2["default"])(_class, "displayName", containerName), _class;
 }
-
 function getRelayProp(environment, refetch) {
   return {
     environment: environment,
     refetch: refetch
   };
 }
+
 /**
  * Wrap the basic `createContainer()` function with logic to adapt to the
  * `context.relay.environment` in which it is rendered. Specifically, the
@@ -399,15 +355,12 @@ function getRelayProp(environment, refetch) {
  * `fragmentSpec` is memoized once per environment, rather than once per
  * instance of the container constructed/rendered.
  */
-
-
 function createContainer(Component, fragmentSpec, taggedNode) {
   // $FlowFixMe[incompatible-return]
   return buildReactRelayContainer(Component, fragmentSpec, function (ComponentClass, fragments) {
     return createContainerWithFragments(ComponentClass, fragments, taggedNode);
   });
 }
-
 module.exports = {
   createContainer: createContainer
 };

package/lib/ReactRelayTestMocker.js

@@ -6,61 +6,52 @@
  *
  * 
  * @format
+ * @oncall relay
  */
+
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
-
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var areEqual = require("fbjs/lib/areEqual");
-
 var invariant = require('invariant');
-
 var _require = require('relay-runtime'),
-    Network = _require.Network,
-    createOperationDescriptor = _require.createOperationDescriptor,
-    isRelayModernEnvironment = _require.isRelayModernEnvironment;
-
+  Network = _require.Network,
+  createOperationDescriptor = _require.createOperationDescriptor,
+  isRelayModernEnvironment = _require.isRelayModernEnvironment;
 var warning = require("fbjs/lib/warning");
-
 /**
  * The next id to return from `generateId()`.
  */
 var nextId = 0;
-
 var ReactRelayTestMocker = /*#__PURE__*/function () {
   function ReactRelayTestMocker(env) {
     (0, _defineProperty2["default"])(this, "_defaults", {});
     (0, _defineProperty2["default"])(this, "_pendingFetches", []);
-
     if (isRelayModernEnvironment(env)) {
       this._mockNetworkLayer(env);
     } else {
       process.env.NODE_ENV !== "production" ? warning(false, 'Network mocking is currently only supported in Relay Modern. ' + 'You will not be able to resolve requests made with Relay ' + 'Classic environments.') : void 0;
     }
-
     this._environment = env;
   }
-
   ReactRelayTestMocker.mockOutEnvironment = function mockOutEnvironment(env) {
     return new ReactRelayTestMocker(env);
   }
+
   /**
    * Get a unique id number (as a string). Note: will wrap around after 2^32
    * calls, if your test needs that many IDs.
    *
    * @returns a unique id string
-   */
-  ;
-
+   */;
   ReactRelayTestMocker.generateId = function generateId() {
     var toRet = nextId.toString();
     nextId++;
     return toRet;
   }
+
   /**
    * Create a unique identifier for a (query, variables) pair.
    * @param request: the request associated with the query
@@ -69,18 +60,15 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
    *
    * @returns a string which can later be used to uniquely identify this query
    * in the list of pending queries
-   */
-  ;
-
+   */;
   ReactRelayTestMocker.getIdentifier = function getIdentifier(request) {
     return request.name;
   }
+
   /**
    * Remove variables that we don't need from the query that will make it more
    * annoying to test (e.g. client_mutation_id, actor_id)
-   */
-  ;
-
+   */;
   ReactRelayTestMocker.stripUnused = function stripUnused(variables) {
     if (variables.input) {
       var toRemove = ['client_mutation_id', 'actor_id', 'clientMutationId', 'actorId'];
@@ -92,23 +80,19 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
       });
       return strippedVariables;
     }
-
     return variables;
   }
+
   /**
    * Replace the environment's network layer with a mocked out one to allow for
    * better testing. Mocking the network allows testing without using a mocked
    * out QueryRenderer, and will allow for easier testing of components wrapped
    * in refetch containers, for example. It also allows test writers to see how
    * their components behave under error conditions.
-   */
-  ;
-
+   */;
   var _proto = ReactRelayTestMocker.prototype;
-
   _proto._mockNetworkLayer = function _mockNetworkLayer(env) {
     var _this = this;
-
     var fetch = function fetch(request, variables, cacheConfig) {
       var resolve;
       var reject;
@@ -117,13 +101,13 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
         reject = rej;
       });
       var strippedVars = ReactRelayTestMocker.stripUnused(variables);
-      var ident = ReactRelayTestMocker.getIdentifier(request); // there's a default value for this query, use it
+      var ident = ReactRelayTestMocker.getIdentifier(request);
 
+      // there's a default value for this query, use it
       if (_this._defaults[ident]) {
         var payload = _this._defaults[ident];
         return typeof payload === 'function' ? payload(strippedVars) : payload;
       }
-
       _this._pendingFetches.push({
         ident: ident,
         cacheConfig: cacheConfig,
@@ -134,16 +118,13 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
         request: request,
         variables: strippedVars
       });
-
       return promise;
     };
-
     var isLoading = function isLoading(ident) {
       return _this._pendingFetches.some(function (pending) {
         return pending.ident === ident;
       });
     };
-
     var resolveRawQuery = function resolveRawQuery(toResolve, payload) {
       _this._pendingFetches = _this._pendingFetches.filter(function (pending) {
         return pending !== toResolve;
@@ -151,7 +132,6 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
       var deferred = toResolve.deferred;
       deferred.resolve(payload);
     };
-
     var rejectQuery = function rejectQuery(toResolve, payload) {
       _this._pendingFetches = _this._pendingFetches.filter(function (pending) {
         return pending !== toResolve;
@@ -159,7 +139,6 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
       var deferred = toResolve.deferred;
       deferred.reject(payload.error);
     };
-
     env.mock = {
       isLoading: isLoading,
       rejectQuery: rejectQuery,
@@ -167,32 +146,29 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
       fetch: fetch
     };
     env.hasMockedNetwork = true;
-
     env.__setNet(Network.create(fetch));
-
     return env;
   }
+
   /**
    * set a default payload for a given query
-   */
-  ;
-
+   */;
   _proto.setDefault = function setDefault(toSet) {
     var query = toSet.query,
-        payload = toSet.payload;
+      payload = toSet.payload;
     var ident = ReactRelayTestMocker.getIdentifier(query.params);
     this._defaults[ident] = payload;
   }
+
   /**
    * remove a default payload for a given query
-   */
-  ;
-
+   */;
   _proto.unsetDefault = function unsetDefault(toUnset) {
     var query = toUnset.query;
     var ident = ReactRelayTestMocker.getIdentifier(query.params);
     delete this._defaults[ident];
   }
+
   /**
    * Write directly to the Relay store instead of trying to resolve a query that
    * was sent via the network.
@@ -200,18 +176,16 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
    * Use this method when testing a component wrapped in a fragment container
    * (via `createFragmentContainer`). The component under test should also be
    * wrapped in a `RelayTestRenderer`.
-   */
-  ;
-
+   */;
   _proto.dataWrite = function dataWrite(config) {
     var query = config.query,
-        variables = config.variables,
-        payload = config.payload;
+      variables = config.variables,
+      payload = config.payload;
     var operationDescriptor = createOperationDescriptor(query, variables);
     !(payload.data != null && payload.errors === undefined) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Only `data` can be written when using `writeDirect`. You may need to ' + 'wrap your payload in an object like `{data: payload}`.') : invariant(false) : void 0;
-
     this._environment.commitPayload(operationDescriptor, payload.data);
   }
+
   /**
    * Write the data specified in config's payload to the instance's environment.
    * NOTE: callers may need to invoke `jest.runOnlyPendingTimers()` after
@@ -219,30 +193,23 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
    *
    * @param config: an object containing the data to write and the query and
    * variables that the payload is simulating a response to
-   */
-  ;
-
+   */;
   _proto.networkWrite = function networkWrite(config) {
     !this._environment.hasMockedNetwork ? process.env.NODE_ENV !== "production" ? invariant(false, 'You cannot resolve queries without a mocked environment. Did you mean ' + 'to use `writeDirect` instead?') : invariant(false) : void 0;
     var query = config.query,
-        variables = config.variables,
-        payload = config.payload;
+      variables = config.variables,
+      payload = config.payload;
     var ident = ReactRelayTestMocker.getIdentifier(query.params);
     var usedVars;
-
     if (variables) {
       var operationDescriptor = createOperationDescriptor(query, variables);
       usedVars = ReactRelayTestMocker.stripUnused(operationDescriptor.request.variables);
     }
-
     var toResolve;
-
     this._pendingFetches.forEach(function (pending) {
       var pendingVars = pending.variables;
-
       if (pending.ident === ident) {
         !(!toResolve || variables) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Multiple queries with the same name are currently pending. You ' + 'should pass variables to `write` so that it can determine which ' + 'to resolve') : invariant(false) : void 0;
-
         if (variables) {
           if (areEqual(pendingVars, usedVars)) {
             toResolve = pending;
@@ -252,12 +219,13 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
         }
       }
     });
-
     var varMessage = usedVars ? ' - variables: ' + JSON.stringify(usedVars) : '';
     !toResolve ? process.env.NODE_ENV !== "production" ? invariant(false, 'You are attempting to resolve a query that has not been fetched ' + '(%s%s).\n\tPlease ensure you passed the correct variables, or use ' + '`writeDirect` instead.', ident, varMessage) : invariant(false) : void 0;
-    var realPayload = // $FlowFixMe[incompatible-call]
-    typeof payload === 'function' ? payload(toResolve.variables) : payload; // if there are errors, reject the query
+    var realPayload =
+    // $FlowFixMe[incompatible-call]
+    typeof payload === 'function' ? payload(toResolve.variables) : payload;
 
+    // if there are errors, reject the query
     if (realPayload.errors != null && realPayload.errors.length > 0) {
       this._environment.mock.rejectQuery(toResolve, {
         error: realPayload.errors[0]
@@ -266,8 +234,6 @@ var ReactRelayTestMocker = /*#__PURE__*/function () {
       this._environment.mock.resolveRawQuery(toResolve, realPayload);
     }
   };
-
   return ReactRelayTestMocker;
 }();
-
 module.exports = ReactRelayTestMocker;