react-relay 14.1.0 → 15.0.0

package/lib/relay-hooks/loadEntryPoint.js

@@ -6,37 +6,36 @@
  *
  * 
  * @format
- * @emails oncall+relay
+ * @oncall relay
  */
+
 'use strict';
 
 var _require = require('./loadQuery'),
-    loadQuery = _require.loadQuery;
-
+  loadQuery = _require.loadQuery;
 function loadEntryPoint(environmentProvider, entryPoint, entryPointParams) {
   // Start loading the code for the entrypoint
   var loadingPromise = null;
-
   if (entryPoint.root.getModuleIfRequired() == null) {
     loadingPromise = entryPoint.root.load();
   }
-
   var preloadProps = entryPoint.getPreloadProps(entryPointParams);
   var queries = preloadProps.queries,
-      entryPoints = preloadProps.entryPoints,
-      extraProps = preloadProps.extraProps;
+    entryPoints = preloadProps.entryPoints,
+    extraProps = preloadProps.extraProps;
   var preloadedQueries = {};
   var preloadedEntryPoints = {};
-
   if (queries != null) {
     var queriesPropNames = Object.keys(queries);
     queriesPropNames.forEach(function (queryPropName) {
       var _queries$queryPropNam = queries[queryPropName],
-          environmentProviderOptions = _queries$queryPropNam.environmentProviderOptions,
-          options = _queries$queryPropNam.options,
-          parameters = _queries$queryPropNam.parameters,
-          variables = _queries$queryPropNam.variables;
+        environmentProviderOptions = _queries$queryPropNam.environmentProviderOptions,
+        options = _queries$queryPropNam.options,
+        parameters = _queries$queryPropNam.parameters,
+        variables = _queries$queryPropNam.variables;
       var environment = environmentProvider.getEnvironment(environmentProviderOptions);
+
+      // $FlowFixMe[underconstrained-implicit-instantiation]
       preloadedQueries[queryPropName] = loadQuery(environment, parameters, variables, {
         fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
         networkCacheConfig: options === null || options === void 0 ? void 0 : options.networkCacheConfig,
@@ -44,75 +43,64 @@ function loadEntryPoint(environmentProvider, entryPoint, entryPointParams) {
       }, environmentProviderOptions);
     });
   }
-
   if (entryPoints != null) {
     var entryPointPropNames = Object.keys(entryPoints);
     entryPointPropNames.forEach(function (entryPointPropName) {
       var entryPointDescription = entryPoints[entryPointPropName];
-
       if (entryPointDescription == null) {
         return;
       }
-
       var nestedEntryPoint = entryPointDescription.entryPoint,
-          nestedParams = entryPointDescription.entryPointParams;
+        nestedParams = entryPointDescription.entryPointParams;
       preloadedEntryPoints[entryPointPropName] = loadEntryPoint(environmentProvider, nestedEntryPoint, nestedParams);
     });
   }
-
   var isDisposed = false;
   return {
     dispose: function dispose() {
       if (isDisposed) {
         return;
       }
-
       if (preloadedQueries != null) {
         Object.values(preloadedQueries).forEach(function (_ref) {
           var innerDispose = _ref.dispose;
           innerDispose();
         });
       }
-
       if (preloadedEntryPoints != null) {
         Object.values(preloadedEntryPoints).forEach(function (_ref2) {
           var innerDispose = _ref2.dispose;
           innerDispose();
         });
       }
-
       isDisposed = true;
     },
     entryPoints: preloadedEntryPoints,
     extraProps: extraProps !== null && extraProps !== void 0 ? extraProps : null,
     getComponent: function getComponent() {
       var componentModule = entryPoint.root.getModuleIfRequired();
-
       if (componentModule == null) {
         var _loadingPromise;
-
         loadingPromise = (_loadingPromise = loadingPromise) !== null && _loadingPromise !== void 0 ? _loadingPromise : entryPoint.root.load();
         throw loadingPromise;
-      } // On certain platforms, getting an es6 module with a default export from a JSResource will return an object like
+      }
+
+      // On certain platforms, getting an es6 module with a default export from a JSResource will return an object like
       // {default: module}, so let's assume that if the "component" has a static property named "default"
       // that it's actually an es6 module wrapper, so unwrap it. This won't work for React classes with a static property named "default", but
       // that's probably a worthwhile trade-off.
-
-
-      var component = // $FlowIgnore[prop-missing]
-      componentModule["default"] != null ? componentModule["default"] : componentModule; // $FlowFixMe[incompatible-cast] - trust me Flow, its entryPoint component
-
+      var component =
+      // $FlowIgnore[prop-missing]
+      componentModule["default"] != null ? componentModule["default"] : componentModule;
+      // $FlowFixMe[incompatible-cast] - trust me Flow, its entryPoint component
       return component;
     },
-
     // $FlowFixMe[unsafe-getters-setters] - this has no side effects
     get isDisposed() {
       return isDisposed;
     },
-
     queries: preloadedQueries,
     rootModuleID: entryPoint.root.getModuleId()
   };
 }
-
 module.exports = loadEntryPoint;

package/lib/relay-hooks/loadQuery.js

@@ -6,51 +6,44 @@
  *
  * 
  * @format
- * @emails oncall+relay
+ * @oncall relay
  */
+
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
-
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
 var invariant = require('invariant');
-
 var React = require('react');
-
 var _require = require('relay-runtime'),
-    Observable = _require.Observable,
-    PreloadableQueryRegistry = _require.PreloadableQueryRegistry,
-    RelayFeatureFlags = _require.RelayFeatureFlags,
-    ReplaySubject = _require.ReplaySubject,
-    fetchQueryDeduped = _require.__internal.fetchQueryDeduped,
-    createOperationDescriptor = _require.createOperationDescriptor,
-    getRequest = _require.getRequest,
-    getRequestIdentifier = _require.getRequestIdentifier;
-
+  fetchQueryDeduped = _require.__internal.fetchQueryDeduped,
+  Observable = _require.Observable,
+  PreloadableQueryRegistry = _require.PreloadableQueryRegistry,
+  RelayFeatureFlags = _require.RelayFeatureFlags,
+  ReplaySubject = _require.ReplaySubject,
+  createOperationDescriptor = _require.createOperationDescriptor,
+  getRequest = _require.getRequest,
+  getRequestIdentifier = _require.getRequestIdentifier;
 var warning = require("fbjs/lib/warning");
-
 var RenderDispatcher = null;
 var fetchKey = 100001;
-
 function useTrackLoadQueryInRender() {
   if (RenderDispatcher === null) {
     var _React$__SECRET_INTER, _React$__SECRET_INTER2;
-
     // Flow does not know of React internals (rightly so), but we need to
     // ensure here that this function isn't called inside render.
     RenderDispatcher = // $FlowFixMe[prop-missing]
     (_React$__SECRET_INTER = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === null || _React$__SECRET_INTER === void 0 ? void 0 : (_React$__SECRET_INTER2 = _React$__SECRET_INTER.ReactCurrentDispatcher) === null || _React$__SECRET_INTER2 === void 0 ? void 0 : _React$__SECRET_INTER2.current;
   }
 }
-
 function loadQuery(environment, preloadableRequest, variables, options, environmentProviderOptions) {
   var _React$__SECRET_INTER3, _React$__SECRET_INTER4, _options$__nameForWar, _options$fetchPolicy;
-
   // This code ensures that we don't call loadQuery during render.
   var CurrentDispatcher = // $FlowFixMe[prop-missing]
   (_React$__SECRET_INTER3 = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === null || _React$__SECRET_INTER3 === void 0 ? void 0 : (_React$__SECRET_INTER4 = _React$__SECRET_INTER3.ReactCurrentDispatcher) === null || _React$__SECRET_INTER4 === void 0 ? void 0 : _React$__SECRET_INTER4.current;
-  process.env.NODE_ENV !== "production" ? warning(RenderDispatcher == null || CurrentDispatcher !== RenderDispatcher, 'Relay: `%s` should not be called inside a React render function.', (_options$__nameForWar = options === null || options === void 0 ? void 0 : options.__nameForWarning) !== null && _options$__nameForWar !== void 0 ? _options$__nameForWar : 'loadQuery') : void 0; // Every time you call loadQuery, we will generate a new fetchKey.
+  process.env.NODE_ENV !== "production" ? warning(RenderDispatcher == null || CurrentDispatcher !== RenderDispatcher, 'Relay: `%s` should not be called inside a React render function.', (_options$__nameForWar = options === null || options === void 0 ? void 0 : options.__nameForWarning) !== null && _options$__nameForWar !== void 0 ? _options$__nameForWar : 'loadQuery') : void 0;
+
+  // Every time you call loadQuery, we will generate a new fetchKey.
   // This will ensure that every query reference that is created and
   // passed to usePreloadedQuery is independently evaluated,
   // even if they are for the same query/variables.
@@ -59,25 +52,26 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
   // cache in usePreloadedQuery reuse the cached result instead of
   // re-evaluating the new query ref and triggering a refetch if
   // necessary.
-
   fetchKey++;
   var fetchPolicy = (_options$fetchPolicy = options === null || options === void 0 ? void 0 : options.fetchPolicy) !== null && _options$fetchPolicy !== void 0 ? _options$fetchPolicy : 'store-or-network';
   var networkCacheConfig = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, options === null || options === void 0 ? void 0 : options.networkCacheConfig), {}, {
     force: true
-  }); // executeWithNetworkSource will retain and execute an operation
+  });
+
+  // executeWithNetworkSource will retain and execute an operation
   // against the Relay store, given an Observable that would provide
   // the network events for the operation.
-
   var retainReference;
   var didExecuteNetworkSource = false;
-
   var executeWithNetworkSource = function executeWithNetworkSource(operation, networkObservable) {
     didExecuteNetworkSource = true;
     return environment.executeWithSource({
       operation: operation,
       source: networkObservable
     });
-  }; // N.B. For loadQuery, we unconventionally want to return an Observable
+  };
+
+  // N.B. For loadQuery, we unconventionally want to return an Observable
   // that isn't lazily executed, meaning that we don't want to wait
   // until the returned Observable is subscribed to to actually start
   // fetching and executing an operation; i.e. we want to execute the
@@ -86,20 +80,17 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
   // allows us to capture the events that occur during the eager execution
   // of the operation, and then replay them to the Observable we
   // ultimately return.
-
-
   var executionSubject = new ReplaySubject();
   var returnedObservable = Observable.create(function (sink) {
     return executionSubject.subscribe(sink);
   });
   var unsubscribeFromNetworkRequest;
-  var networkError = null; // makeNetworkRequest will immediately start a raw network request if
+  var networkError = null;
+  // makeNetworkRequest will immediately start a raw network request if
   // one isn't already in flight and return an Observable that when
   // subscribed to will replay the network events that have occured so far,
   // as well as subsequent events.
-
   var didMakeNetworkRequest = false;
-
   var makeNetworkRequest = function makeNetworkRequest(params) {
     // N.B. this function is called synchronously or not at all
     // didMakeNetworkRequest is safe to rely on in the returned value
@@ -110,7 +101,6 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
     didMakeNetworkRequest = true;
     var observable;
     var subject = new ReplaySubject();
-
     if (RelayFeatureFlags.ENABLE_LOAD_QUERY_REQUEST_DEDUPING === true) {
       // Here, we are calling fetchQueryDeduped at the network layer level,
       // which ensures that only a single network request is active for a given
@@ -136,21 +126,19 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
       var network = environment.getNetwork();
       observable = network.execute(params, variables, networkCacheConfig);
     }
-
     var _observable$subscribe = observable.subscribe({
-      error: function error(err) {
-        networkError = err;
-        subject.error(err);
-      },
-      next: function next(data) {
-        subject.next(data);
-      },
-      complete: function complete() {
-        subject.complete();
-      }
-    }),
-        unsubscribe = _observable$subscribe.unsubscribe;
-
+        error: function error(err) {
+          networkError = err;
+          subject.error(err);
+        },
+        next: function next(data) {
+          subject.next(data);
+        },
+        complete: function complete() {
+          subject.complete();
+        }
+      }),
+      unsubscribe = _observable$subscribe.unsubscribe;
     unsubscribeFromNetworkRequest = unsubscribe;
     return Observable.create(function (sink) {
       var subjectSubscription = subject.subscribe(sink);
@@ -160,9 +148,7 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
       };
     });
   };
-
   var unsubscribeFromExecution;
-
   var executeDeduped = function executeDeduped(operation, fetchFn) {
     if (RelayFeatureFlags.ENABLE_LOAD_QUERY_REQUEST_DEDUPING === true) {
       // N.B. at this point, if we're calling execute with a query ast (OperationDescriptor),
@@ -174,7 +160,9 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
       // so we set this to true before deduping, to guarantee that the `source`
       // observable is returned.
       didMakeNetworkRequest = true;
-    } // Here, we are calling fetchQueryDeduped, which ensures that only
+    }
+
+    // Here, we are calling fetchQueryDeduped, which ensures that only
     // a single operation is active for a given (environment, identifier) pair,
     // and also tracks the active state of the operation, which is necessary
     // for our Suspense infra to later be able to suspend (or not) on
@@ -188,8 +176,6 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
     // - If no duplicate active operation is found, it will call the fetchFn
     // to execute the operation, and return an Observable that will provide
     // the events for executing the operation.
-
-
     var _fetchQueryDeduped$su = fetchQueryDeduped(environment, operation.request.identifier, fetchFn).subscribe({
       error: function error(err) {
         executionSubject.error(err);
@@ -201,23 +187,19 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
         executionSubject.complete();
       }
     });
-
     unsubscribeFromExecution = _fetchQueryDeduped$su.unsubscribe;
   };
-
   var checkAvailabilityAndExecute = function checkAvailabilityAndExecute(concreteRequest) {
     var operation = createOperationDescriptor(concreteRequest, variables, networkCacheConfig);
     retainReference = environment.retain(operation);
-
     if (fetchPolicy === 'store-only') {
       return;
-    } // N.B. If the fetch policy allows fulfillment from the store but the
+    }
+
+    // N.B. If the fetch policy allows fulfillment from the store but the
     // environment already has the data for that operation cached in the store,
     // then we do nothing.
-
-
     var shouldFetch = fetchPolicy !== 'store-or-network' || environment.check(operation).status !== 'available';
-
     if (shouldFetch) {
       executeDeduped(operation, function () {
         // N.B. Since we have the operation synchronously available here,
@@ -228,20 +210,16 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
       });
     }
   };
-
   var params;
   var cancelOnLoadCallback;
   var queryId;
-
   if (preloadableRequest.kind === 'PreloadableConcreteRequest') {
     var preloadableConcreteRequest = preloadableRequest;
     params = preloadableConcreteRequest.params;
     var _params = params;
     queryId = _params.id;
     !(queryId !== null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Relay: `loadQuery` requires that preloadable query `%s` has a persisted query id', params.name) : invariant(false) : void 0;
-
     var _module = PreloadableQueryRegistry.get(queryId);
-
     if (_module != null) {
       checkAvailabilityAndExecute(_module);
     } else {
@@ -252,20 +230,18 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
       // ast, and we know that if we don't have the query ast
       // available, then this query could've never been written to the
       // store in the first place, so it couldn't have been cached.
-      var networkObservable = fetchPolicy === 'store-only' ? null : makeNetworkRequest(params); // $FlowFixMe[method-unbinding] added when improving typing for this parameters
-
+      var networkObservable = fetchPolicy === 'store-only' ? null : makeNetworkRequest(params);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
       var _PreloadableQueryRegi = PreloadableQueryRegistry.onLoad(queryId, function (preloadedModule) {
         cancelOnLoadCallback();
         var operation = createOperationDescriptor(preloadedModule, variables, networkCacheConfig);
         retainReference = environment.retain(operation);
-
         if (networkObservable != null) {
           executeDeduped(operation, function () {
             return executeWithNetworkSource(operation, networkObservable);
           });
         }
       });
-
       cancelOnLoadCallback = _PreloadableQueryRegi.dispose;
     }
   } else {
@@ -275,35 +251,28 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
     queryId = params.cacheID != null ? params.cacheID : params.id;
     checkAvailabilityAndExecute(request);
   }
-
   var isDisposed = false;
   var isReleased = false;
   var isNetworkRequestCancelled = false;
-
   var releaseQuery = function releaseQuery() {
     if (isReleased) {
       return;
     }
-
     retainReference && retainReference.dispose();
     isReleased = true;
   };
-
   var cancelNetworkRequest = function cancelNetworkRequest() {
     if (isNetworkRequestCancelled) {
       return;
     }
-
     if (didExecuteNetworkSource) {
       unsubscribeFromExecution && unsubscribeFromExecution();
     } else {
       unsubscribeFromNetworkRequest && unsubscribeFromNetworkRequest();
     }
-
     cancelOnLoadCallback && cancelOnLoadCallback();
     isNetworkRequestCancelled = true;
   };
-
   return {
     kind: 'PreloadedQuery',
     environment: environment,
@@ -312,7 +281,6 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
       if (isDisposed) {
         return;
       }
-
       releaseQuery();
       cancelNetworkRequest();
       isDisposed = true;
@@ -321,17 +289,14 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
     cancelNetworkRequest: cancelNetworkRequest,
     fetchKey: fetchKey,
     id: queryId,
-
     // $FlowFixMe[unsafe-getters-setters] - this has no side effects
     get isDisposed() {
       return isDisposed || isReleased;
     },
-
     // $FlowFixMe[unsafe-getters-setters] - this has no side effects
     get networkError() {
       return networkError;
     },
-
     name: params.name,
     networkCacheConfig: networkCacheConfig,
     fetchPolicy: fetchPolicy,
@@ -339,7 +304,6 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
     variables: variables
   };
 }
-
 module.exports = {
   loadQuery: loadQuery,
   useTrackLoadQueryInRender: useTrackLoadQueryInRender

package/lib/relay-hooks/preloadQuery_DEPRECATED.js

@@ -4,65 +4,53 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
+
 'use strict';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
-
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
 var _require = require('relay-runtime'),
-    Observable = _require.Observable,
-    PreloadableQueryRegistry = _require.PreloadableQueryRegistry,
-    RelayFeatureFlags = _require.RelayFeatureFlags,
-    ReplaySubject = _require.ReplaySubject,
-    createOperationDescriptor = _require.createOperationDescriptor,
-    getRequest = _require.getRequest,
-    getRequestIdentifier = _require.getRequestIdentifier; // Expire results by this delay after they resolve.
-
-
+  Observable = _require.Observable,
+  PreloadableQueryRegistry = _require.PreloadableQueryRegistry,
+  ReplaySubject = _require.ReplaySubject,
+  createOperationDescriptor = _require.createOperationDescriptor,
+  getRequest = _require.getRequest,
+  getRequestIdentifier = _require.getRequestIdentifier;
+
+// Expire results by this delay after they resolve.
 var DEFAULT_PREFETCH_TIMEOUT = 30 * 1000; // 30 seconds
 
 var WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
 var STORE_OR_NETWORK_DEFAULT = 'store-or-network';
 var pendingQueriesByEnvironment = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();
-
 function preloadQuery(environment, preloadableRequest, variables, options, environmentProviderOptions) {
   var _pendingQueries = pendingQueriesByEnvironment.get(environment);
-
   if (_pendingQueries == null) {
     _pendingQueries = new Map();
     pendingQueriesByEnvironment.set(environment, _pendingQueries);
   }
-
   var pendingQueries = _pendingQueries; // store in a const for flow
-
   var queryEntry = preloadQueryDeduped(environment, pendingQueries, preloadableRequest, variables, options);
   var source = queryEntry.kind === 'network' ? Observable.create(function (sink) {
     var subscription;
-
     if (pendingQueries.get(queryEntry.cacheKey) == null) {
       var newQueryEntry = preloadQueryDeduped(environment, pendingQueries, preloadableRequest, variables, options);
-
       if (newQueryEntry.kind === 'network') {
         subscription = newQueryEntry.subject.subscribe(sink);
       }
     } else {
       subscription = queryEntry.subject.subscribe(sink);
     }
-
     return function () {
       var _subscription;
-
       (_subscription = subscription) === null || _subscription === void 0 ? void 0 : _subscription.unsubscribe();
-
       if (environment.isServer()) {
         return;
       }
-
       setTimeout(function () {
         // Clear the cache entry after the default timeout
         // null-check for Flow
@@ -86,13 +74,10 @@ function preloadQuery(environment, preloadableRequest, variables, options, envir
     status: queryEntry.status
   };
 }
-
 function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, variables, options) {
   var _options$fetchPolicy;
-
   var params;
   var query;
-
   if (preloadableRequest.kind === 'PreloadableConcreteRequest') {
     var preloadableConcreteRequest = preloadableRequest;
     params = preloadableConcreteRequest.params;
@@ -101,7 +86,6 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
     query = getRequest(preloadableRequest);
     params = query.params;
   }
-
   var network = environment.getNetwork();
   var fetchPolicy = (_options$fetchPolicy = options === null || options === void 0 ? void 0 : options.fetchPolicy) !== null && _options$fetchPolicy !== void 0 ? _options$fetchPolicy : STORE_OR_NETWORK_DEFAULT;
   var fetchKey = options === null || options === void 0 ? void 0 : options.fetchKey;
@@ -114,10 +98,8 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
     status: 'missing'
   };
   var nextQueryEntry;
-
   if (availability.status === 'available' && query != null) {
     var _availability$fetchTi;
-
     nextQueryEntry = prevQueryEntry && prevQueryEntry.kind === 'cache' ? prevQueryEntry : {
       cacheKey: cacheKey,
       fetchKey: fetchKey,
@@ -131,7 +113,6 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
         fetchTime: (_availability$fetchTi = availability === null || availability === void 0 ? void 0 : availability.fetchTime) !== null && _availability$fetchTi !== void 0 ? _availability$fetchTi : null
       }
     };
-
     if (!environment.isServer() && prevQueryEntry == null) {
       setTimeout(function () {
         // Clear the cache entry after the default timeout
@@ -162,7 +143,6 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
         if (environment.isServer()) {
           return;
         }
-
         setTimeout(function () {
           // Clear the cache entry after the default timeout
           // null-check for Flow
@@ -185,25 +165,20 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
   } else {
     nextQueryEntry = prevQueryEntry;
   }
-
   pendingQueries.set(cacheKey, nextQueryEntry);
   return nextQueryEntry;
 }
-
 function cleanup(pendingQueries, entry) {
   // Reload the entry by its cache key and only invalidate if its the identical
   // entry instance. This ensures that if the same query/variables are fetched
   // successively that a timeout/expiration from an earlier fetch doesn't clear
   // a subsequent fetch.
   var currentEntry = pendingQueries.get(entry.cacheKey);
-
   if (currentEntry != null && currentEntry === entry) {
     if (currentEntry.kind === 'network') {
       currentEntry.subscription.unsubscribe();
     }
-
     pendingQueries["delete"](currentEntry.cacheKey);
   }
 }
-
 module.exports = preloadQuery;

package/lib/relay-hooks/prepareEntryPoint_DEPRECATED.js

@@ -4,53 +4,48 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
+
 'use strict';
 
 var preloadQuery = require('./preloadQuery_DEPRECATED');
-
 function prepareEntryPoint(environmentProvider, entryPoint, entryPointParams) {
   // Start loading the code for the entrypoint
   if (entryPoint.root.getModuleIfRequired() == null) {
+    // $FlowFixMe[unused-promise]
     entryPoint.root.load();
   }
-
   var preloadProps = entryPoint.getPreloadProps(entryPointParams);
   var queries = preloadProps.queries,
-      entryPoints = preloadProps.entryPoints;
+    entryPoints = preloadProps.entryPoints;
   var preloadedQueries = {};
   var preloadedEntryPoints = {};
-
   if (queries != null) {
     var queriesPropNames = Object.keys(queries);
     queriesPropNames.forEach(function (queryPropName) {
       var _queries$queryPropNam = queries[queryPropName],
-          environmentProviderOptions = _queries$queryPropNam.environmentProviderOptions,
-          options = _queries$queryPropNam.options,
-          parameters = _queries$queryPropNam.parameters,
-          variables = _queries$queryPropNam.variables;
+        environmentProviderOptions = _queries$queryPropNam.environmentProviderOptions,
+        options = _queries$queryPropNam.options,
+        parameters = _queries$queryPropNam.parameters,
+        variables = _queries$queryPropNam.variables;
       var environment = environmentProvider.getEnvironment(environmentProviderOptions);
       preloadedQueries[queryPropName] = preloadQuery(environment, parameters, variables, options, environmentProviderOptions);
     });
   }
-
   if (entryPoints != null) {
     var entryPointPropNames = Object.keys(entryPoints);
     entryPointPropNames.forEach(function (entryPointPropName) {
       var entryPointDescription = entryPoints[entryPointPropName];
-
       if (entryPointDescription == null) {
         return;
       }
-
       var nestedEntryPoint = entryPointDescription.entryPoint,
-          nestedParams = entryPointDescription.entryPointParams;
+        nestedParams = entryPointDescription.entryPointParams;
       preloadedEntryPoints[entryPointPropName] = prepareEntryPoint(environmentProvider, nestedEntryPoint, nestedParams);
     });
   }
 }
-
 module.exports = prepareEntryPoint;