react-relay 15.0.0 → 16.0.0

package/lib/relay-hooks/LazyLoadEntryPointContainer_DEPRECATED.react.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 preloadQuery_DEPRECATED = require('./preloadQuery_DEPRECATED');
@@ -26,7 +15,6 @@ function stableStringify(value) {
   return (_JSON$stringify = JSON.stringify(stableCopy(value))) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : 'null';
 }
 function prepareEntryPoint(environmentProvider, entryPoint, entryPointParams) {
-  // Start loading the code for the entrypoint
   var loadingPromise = null;
   if (entryPoint.root.getModuleIfRequired() == null) {
     loadingPromise = entryPoint.root.load();
@@ -71,7 +59,6 @@ function prepareEntryPoint(environmentProvider, entryPoint, entryPointParams) {
         loadingPromise = (_loadingPromise = loadingPromise) !== null && _loadingPromise !== void 0 ? _loadingPromise : entryPoint.root.load();
         throw loadingPromise;
       }
-      // $FlowFixMe[incompatible-cast] - trust me Flow, its entryPoint component
       return component;
     },
     queries: preloadedQueries,
@@ -85,9 +72,6 @@ function LazyLoadEntryPointContainer_DEPRECATED(_ref) {
     environmentProvider = _ref.environmentProvider;
   var environment = useRelayEnvironment();
   var getPreloadProps = entryPoint.getPreloadProps;
-  // IMPORTANT: Loading the component may suspend (throw), so the props
-  // *must* be computed first to fetch the component's data-dependencies in
-  // parallel with the component itself (the code).
   var entryPointParamsHash = stableStringify(entryPointParams);
   var _useMemo = useMemo(function () {
       return prepareEntryPoint(environmentProvider !== null && environmentProvider !== void 0 ? environmentProvider : {
@@ -95,8 +79,6 @@ function LazyLoadEntryPointContainer_DEPRECATED(_ref) {
           return environment;
         }
       }, entryPoint, entryPointParams);
-      // NOTE: stableParams encodes the information from params
-      // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [environment, environmentProvider, getPreloadProps, entryPointParamsHash]),
     getComponent = _useMemo.getComponent,
     queries = _useMemo.queries,

package/lib/relay-hooks/MatchContainer.js

@@ -1,92 +1,9 @@
-/**
- * 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"];
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = require('react');
 var useMemo = React.useMemo;
-
-/**
- * Renders the results of a data-driven dependency fetched with the `@match`
- * directive. The `@match` directive can be used to specify a mapping of
- * result types to the containers used to render those types. The result
- * value is an opaque object that described which component was selected
- * and a reference to its data. Use <MatchContainer/> to render these
- * values.
- *
- * ## Example
- *
- * For example, consider a piece of media content that might be text or
- * an image, where for clients that don't support images the application
- * should fall back to rendering the image caption as text. @match can be
- * used to dynamically select whether to render a given media item as
- * an image or text (on the server) and then fetch the corresponding
- * React component and its data dependencies (information about the
- * image or about the text).
- *
- * ```
- * // Media.react.js
- *
- * // Define a React component that uses <MatchContainer /> to render the
- * // results of a @module selection
- * function Media(props) {
- *   const {media, ...restProps} = props;
- *
- *   const loader = moduleReference => {
- *      // given the data returned by your server for the @module directive,
- *      // return the React component (or throw a Suspense promise if
- *      // it is loading asynchronously).
- *      todo_returnModuleOrThrowPromise(moduleReference);
- *   };
- *   return <MatchContainer
- *     loader={loader}
- *     match={media.mediaAttachment}
- *     props={restProps}
- *   />;
- * }
- *
- * module.exports = createSuspenseFragmentContainer(
- *   Media,
- *   {
- *     media: graphql`
- *       fragment Media_media on Media {
- *         # ...
- *         mediaAttachment @match {
- *            ...ImageContainer_image @module(name: "ImageContainer.react")
- *            ...TextContainer_text @module(name: "TextContainer.react")
- *         }
- *       }
- *     `
- *   },
- * );
- * ```
- *
- * ## API
- *
- * MatchContainer accepts the following props:
- * - `match`: The results (an opaque object) of a `@match` field.
- * - `props`: Props that should be passed through to the dynamically
- *   selected component. Note that any of the components listed in
- *   `@module()` could be selected, so all components should accept
- *   the value passed here.
- * - `loader`: A function to load a module given a reference (whatever
- *   your server returns for the `js(moduleName: String)` field).
- *
- */
-
-// Note: this type is intentionally non-exact, it is expected that the
-// object may contain sibling fields.
-
 function MatchContainer(_ref2) {
   var _ref;
   var fallback = _ref2.fallback,
@@ -96,13 +13,6 @@ function MatchContainer(_ref2) {
   if (match != null && typeof match !== 'object') {
     throw new Error('MatchContainer: Expected `match` value to be an object or null/undefined.');
   }
-  // NOTE: the MatchPointer type has a $fragmentSpreads field to ensure that only
-  // an object that contains a FragmentSpread can be passed. If the fragment
-  // spread matches, then the metadata fields below (__id, __fragments, etc.)
-  // will be present. But they can be missing if all the fragment spreads use
-  // @module and none of the types matched. The cast here is necessary because
-  // fragment Flow types don't describe metadata fields, only the actual schema
-  // fields the developer selected.
   var _ref3 = (_ref = match) !== null && _ref !== void 0 ? _ref : {},
     __id = _ref3.__id,
     __fragments = _ref3.__fragments,
@@ -114,8 +24,6 @@ function MatchContainer(_ref2) {
   }
   var LoadedContainer = __module_component != null ? loader(__module_component) : null;
   var fragmentProps = useMemo(function () {
-    // TODO: Perform this transformation in RelayReader so that unchanged
-    // output of subscriptions already has a stable identity.
     if (__fragmentPropName != null && __id != null && __fragments != null) {
       var fragProps = {};
       fragProps[__fragmentPropName] = {
@@ -128,8 +36,6 @@ function MatchContainer(_ref2) {
     return null;
   }, [__id, __fragments, __fragmentOwner, __fragmentPropName]);
   if (LoadedContainer != null && fragmentProps != null) {
-    // $FlowFixMe[incompatible-type]
-    // $FlowFixMe[cannot-spread-indexer]
     return /*#__PURE__*/React.createElement(LoadedContainer, (0, _extends2["default"])({}, props, fragmentProps));
   } else {
     return fallback !== null && fallback !== void 0 ? fallback : null;

package/lib/relay-hooks/NestedRelayEntryPointBuilderUtils.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NestedRelayEntryPoint = NestedRelayEntryPoint;
+function NestedRelayEntryPoint(params) {
+  return params;
+}

package/lib/relay-hooks/ProfilerContext.js

@@ -1,18 +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
- */
-
-// This contextual profiler can be used to wrap a react sub-tree. It will bind
-// the RelayProfiler during the render phase of these components. Allows
-// collecting metrics for a specific part of your application.
-
 'use strict';
 
 var React = require('react');

package/lib/relay-hooks/QueryResource.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"];
@@ -58,9 +47,6 @@ function createCacheEntry(cacheIdentifier, operation, operationAvailability, val
     var retention = environment.retain(operation);
     return {
       dispose: function dispose() {
-        // Normally if this entry never commits, the request would've ended by the
-        // time this timeout expires and the temporary retain is released. However,
-        // we need to do this for live queries which remain open indefinitely.
         if (isLiveQuery && currentNetworkSubscription != null) {
           currentNetworkSubscription.unsubscribe();
         }
@@ -111,34 +97,17 @@ var QueryResourceImpl = /*#__PURE__*/function () {
   _proto.prepare = function prepare(operation, fetchObservable, maybeFetchPolicy, maybeRenderPolicy, observer, cacheBreaker, profilerContext) {
     var cacheIdentifier = getQueryCacheIdentifier(this._environment, operation, maybeFetchPolicy, maybeRenderPolicy, cacheBreaker);
     return this.prepareWithIdentifier(cacheIdentifier, operation, fetchObservable, maybeFetchPolicy, maybeRenderPolicy, observer, profilerContext);
-  }
-
-  /**
-   * This function should be called during a Component's render function,
-   * to either read an existing cached value for the query, or fetch the query
-   * and suspend.
-   */;
+  };
   _proto.prepareWithIdentifier = function prepareWithIdentifier(cacheIdentifier, operation, fetchObservable, maybeFetchPolicy, maybeRenderPolicy, observer, profilerContext) {
     var environment = this._environment;
     var fetchPolicy = maybeFetchPolicy !== null && maybeFetchPolicy !== void 0 ? maybeFetchPolicy : operationIsLiveQuery(operation) ? DEFAULT_LIVE_FETCH_POLICY : DEFAULT_FETCH_POLICY;
     var renderPolicy = maybeRenderPolicy !== null && maybeRenderPolicy !== void 0 ? maybeRenderPolicy : environment.UNSTABLE_getDefaultRenderPolicy();
-
-    // 1. Check if there's a cached value for this operation, and reuse it if
-    // it's available
     var cacheEntry = this._cache.get(cacheIdentifier);
     var temporaryRetainDisposable = null;
     var entryWasCached = cacheEntry != null;
     if (cacheEntry == null) {
-      // 2. If a cached value isn't available, try fetching the operation.
-      // _fetchAndSaveQuery will update the cache with either a Promise or
-      // an Error to throw, or a QueryResult to return.
       cacheEntry = this._fetchAndSaveQuery(cacheIdentifier, operation, fetchObservable, fetchPolicy, renderPolicy, profilerContext, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, observer), {}, {
         unsubscribe: function unsubscribe(subscription) {
-          // 4. If the request is cancelled, make sure to dispose
-          // of the temporary retain; this will ensure that a promise
-          // doesn't remain unnecessarily cached until the temporary retain
-          // expires. Not clearing the temporary retain might cause the
-          // query to incorrectly re-suspend.
           if (temporaryRetainDisposable != null) {
             temporaryRetainDisposable.dispose();
           }
@@ -147,12 +116,6 @@ var QueryResourceImpl = /*#__PURE__*/function () {
         }
       }));
     }
-
-    // 3. Temporarily retain here in render phase. When the component reading
-    // the operation is committed, we will transfer ownership of data retention
-    // to the component.
-    // In case the component never commits (mounts or updates) from this render,
-    // this data retention hold will auto-release itself after a timeout.
     temporaryRetainDisposable = cacheEntry.temporaryRetain(environment);
     var cachedValue = cacheEntry.getValue();
     if (isPromise(cachedValue)) {
@@ -170,13 +133,7 @@ var QueryResourceImpl = /*#__PURE__*/function () {
       throw cachedValue;
     }
     return cachedValue;
-  }
-
-  /**
-   * This function should be called during a component's commit phase
-   * (e.g. inside useEffect), in order to retain the operation in the Relay store
-   * and transfer ownership of the operation to the component lifecycle.
-   */;
+  };
   _proto.retain = function retain(queryResult, profilerContext) {
     var environment = this._environment;
     var cacheIdentifier = queryResult.cacheIdentifier,
@@ -216,19 +173,12 @@ var QueryResourceImpl = /*#__PURE__*/function () {
   _proto._fetchAndSaveQuery = function _fetchAndSaveQuery(cacheIdentifier, operation, fetchObservable, fetchPolicy, renderPolicy, profilerContext, observer) {
     var _this2 = this;
     var environment = this._environment;
-
-    // NOTE: Running `check` will write missing data to the store using any
-    // missing data handlers specified on the environment;
-    // We run it here first to make the handlers get a chance to populate
-    // missing data.
     var queryAvailability = environment.check(operation);
     var queryStatus = queryAvailability.status;
     var hasFullQuery = queryStatus === 'available';
     var canPartialRender = hasFullQuery || renderPolicy === 'partial' && queryStatus !== 'stale';
     var shouldFetch;
     var shouldAllowRender;
-    // Different definitions for Promise in our repos can cause this variable
-    // to cause errors when synced elsewhere
     var resolveNetworkPromise = function resolveNetworkPromise() {};
     switch (fetchPolicy) {
       case 'store-only':
@@ -257,11 +207,6 @@ var QueryResourceImpl = /*#__PURE__*/function () {
           break;
         }
     }
-
-    // NOTE: If this value is false, we will cache a promise for this
-    // query, which means we will suspend here at this query root.
-    // If it's true, we will cache the query resource and allow rendering to
-    // continue.
     if (shouldAllowRender) {
       var queryResult = getQueryResult(operation, cacheIdentifier);
       var _cacheEntry = createCacheEntry(cacheIdentifier, operation, queryAvailability, queryResult, null, this._clearCacheEntry);
@@ -281,7 +226,6 @@ var QueryResourceImpl = /*#__PURE__*/function () {
           if (observerStart) {
             var subscriptionWithConditionalCancelation = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, subscription), {}, {
               unsubscribe: function unsubscribe() {
-                // Only live queries should have their network requests canceled.
                 if (operationIsLiveQuery(operation)) {
                   subscription.unsubscribe();
                 }
@@ -303,17 +247,9 @@ var QueryResourceImpl = /*#__PURE__*/function () {
         },
         error: function error(_error) {
           var cacheEntry = _this2._getOrCreateCacheEntry(cacheIdentifier, operation, queryAvailability, _error, networkSubscription);
-
-          // If, this is the first thing we receive for the query,
-          // before any other payload handled is error, we will cache and
-          // re-throw that error later.
-
-          // We will ignore errors for any incremental payloads we receive.
           if (cacheEntry.processedPayloadsCount === 0) {
             cacheEntry.setValue(_error);
           } else {
-            // TODO:T92030819 Remove this warning and actually throw the network error
-            // To complete this task we need to have a way of precisely tracking suspendable points
             process.env.NODE_ENV !== "production" ? warning(false, 'QueryResource: An incremental payload for query `%s` returned an error: `%s`.', operation.fragment.node.name, String(_error.message)) : void 0;
           }
           resolveNetworkPromise();
@@ -339,8 +275,6 @@ var QueryResourceImpl = /*#__PURE__*/function () {
         var networkPromise = new Promise(function (resolve) {
           resolveNetworkPromise = resolve;
         });
-
-        // $FlowExpectedError[prop-missing] Expando to annotate Promises.
         networkPromise.displayName = 'Relay(' + operation.fragment.node.name + ')';
         _cacheEntry2 = createCacheEntry(cacheIdentifier, operation, queryAvailability, networkPromise, networkSubscription, this._clearCacheEntry);
         this._cache.set(cacheIdentifier, _cacheEntry2);

package/lib/relay-hooks/RelayEnvironmentProvider.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 ReactRelayContext = require('./../ReactRelayContext');

package/lib/relay-hooks/SuspenseResource.js

@@ -1,26 +1,9 @@
-/**
- * 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"];
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var invariant = require('invariant');
 var TEMPORARY_RETAIN_DURATION_MS = 5 * 60 * 1000;
-
-/**
- * Allows you to retain a resource as part of a component lifecycle accounting
- * for Suspense. You temporarily retain the resource during render, then
- * permanently retain it during commit and release it during unmount.
- */
 var SuspenseResource = /*#__PURE__*/function () {
   function SuspenseResource(retain) {
     var _this = this;
@@ -48,20 +31,11 @@ var SuspenseResource = /*#__PURE__*/function () {
   _proto.temporaryRetain = function temporaryRetain(environment) {
     var _this2 = this;
     var _this$_releaseTempora;
-    // If we're executing in a server environment, there's no need
-    // to create temporary retains, since the component will never commit.
     if (environment.isServer()) {
       return {
         dispose: function dispose() {}
       };
     }
-
-    // temporaryRetain is called during the render phase. However,
-    // given that we can't tell if this render will eventually commit or not,
-    // we create a timer to autodispose of this retain in case the associated
-    // component never commits.
-    // If the component /does/ commit, permanentRetain will clear this timeout
-    // and permanently retain the data.
     var retention = this._retain(environment);
     var releaseQueryTimeout = null;
     var releaseTemporaryRetain = function releaseTemporaryRetain() {
@@ -71,14 +45,6 @@ var SuspenseResource = /*#__PURE__*/function () {
       retention.dispose();
     };
     releaseQueryTimeout = setTimeout(releaseTemporaryRetain, TEMPORARY_RETAIN_DURATION_MS);
-
-    // NOTE: Since temporaryRetain can be called multiple times, we release
-    // the previous temporary retain after we re-establish a new one, since
-    // we only ever need a single temporary retain until the permanent retain is
-    // established.
-    // temporaryRetain may be called multiple times by React during the render
-    // phase, as well as multiple times by other query components that are
-    // rendering the same query/variables.
     (_this$_releaseTempora = this._releaseTemporaryRetain) === null || _this$_releaseTempora === void 0 ? void 0 : _this$_releaseTempora.call(this);
     this._releaseTemporaryRetain = releaseTemporaryRetain;
     return {

package/lib/relay-hooks/loadEntryPoint.js

@@ -1,20 +1,8 @@
-/**
- * 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 _require = 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();
@@ -34,8 +22,6 @@ function loadEntryPoint(environmentProvider, entryPoint, entryPointParams) {
         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,
@@ -84,18 +70,9 @@ function loadEntryPoint(environmentProvider, entryPoint, entryPointParams) {
         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
-      // {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 = componentModule["default"] != null ? componentModule["default"] : componentModule;
       return component;
     },
-    // $FlowFixMe[unsafe-getters-setters] - this has no side effects
     get isDisposed() {
       return isDisposed;
     },

package/lib/relay-hooks/loadQuery.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"];
@@ -30,37 +19,18 @@ 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;
+    RenderDispatcher = (_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;
+  var CurrentDispatcher = (_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.
-  // 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.
-  // Specifically, we want to avoid a case where we try to refetch a
-  // query by calling loadQuery a second time, and have the Suspense
-  // 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
-  // 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) {
@@ -70,53 +40,18 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
       source: networkObservable
     });
   };
-
-  // 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
-  // operation eagerly, when loadQuery is called.
-  // For this reason, we use an intermediate executionSubject which
-  // 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
-  // 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
-    // Even if the request gets deduped below, we still wan't to return an
-    // observable that provides the replayed network events for the query,
-    // so we set this to true before deduping, to guarantee that the
-    // `source` observable is returned.
     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
-      // (environment, identifier) pair.
-      // Since network requests can be started /before/ we have the query ast
-      // necessary to process the results, we need to dedupe the raw requests
-      // separately from deduping the operation execution; specifically,
-      // if `loadQuery` is called multiple times before the query ast is available,
-      // we still want the network request to be deduped.
-      // - If a duplicate active network request is found, it will return an
-      // Observable that replays the events of the already active request.
-      // - If no duplicate active network request is found, it will call the fetchFn
-      // to start the request, and return an Observable that will replay
-      // the events from the network request.
-      // We provide an extra key to the identifier to distinguish deduping
-      // of raw network requests vs deduping of operation executions.
       var identifier = 'raw-network-request-' + getRequestIdentifier(params, variables);
       observable = fetchQueryDeduped(environment, identifier, function () {
         var network = environment.getNetwork();
@@ -151,31 +86,8 @@ 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),
-      // we are guaranteed to have started a network request. We set this to
-      // true here as well since `makeNetworkRequest` might get skipped in the case
-      // where the query ast is already available and the query executions get deduped.
-      // Even if the execution gets deduped below, we still wan't to return
-      // an observable that provides the replayed network events for the query,
-      // 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
-    // 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
-    // active operations. Even though we already dedupe raw network requests,
-    // we also need to dedupe and keep track operation execution for our Suspense
-    // infra, and we also want to avoid processing responses more than once, for
-    // the cases where `loadQuery` might be called multiple times after the query ast
-    // is available.
-    // - If a duplicate active operation is found, it will return an
-    // Observable that replays the events of the already active operation.
-    // - 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);
@@ -195,15 +107,9 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
     if (fetchPolicy === 'store-only') {
       return;
     }
-
-    // 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,
-        // we can immediately fetch and execute the operation.
         var networkObservable = makeNetworkRequest(concreteRequest.params);
         var executeObservable = executeWithNetworkSource(operation, networkObservable);
         return executeObservable;
@@ -223,15 +129,7 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
     if (_module != null) {
       checkAvailabilityAndExecute(_module);
     } else {
-      // If the module isn't synchronously available, we launch the
-      // network request immediately if the fetchPolicy might produce
-      // a network fetch, regardless of the state of the store cache. We
-      // do this because we can't check if a query is cached without the
-      // 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 _PreloadableQueryRegi = PreloadableQueryRegistry.onLoad(queryId, function (preloadedModule) {
         cancelOnLoadCallback();
         var operation = createOperationDescriptor(preloadedModule, variables, networkCacheConfig);
@@ -289,11 +187,9 @@ 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;
     },