react-relay 15.0.0 → 16.1.0

package/lib/relay-hooks/{react-cache/useRefetchableFragment_REACT_CACHE.js → experimental/useRefetchableFragment_EXPERIMENTAL.js}

@@ -1,18 +1,7 @@
-/**
- * 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 useStaticFragmentNodeWarning = require('../useStaticFragmentNodeWarning');
-var useRefetchableFragmentInternal = require('./useRefetchableFragmentInternal_REACT_CACHE');
+var useRefetchableFragmentInternal = require('./useRefetchableFragmentInternal_EXPERIMENTAL');
 var _require = require('react'),
   useDebugValue = _require.useDebugValue;
 var _require2 = require('relay-runtime'),
@@ -24,14 +13,11 @@ function useRefetchableFragment(fragmentInput, fragmentRef) {
     fragmentData = _useRefetchableFragme.fragmentData,
     refetch = _useRefetchableFragme.refetch;
   if (process.env.NODE_ENV !== "production") {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
     useDebugValue({
       fragment: fragmentNode.name,
       data: fragmentData
     });
   }
-  /* $FlowExpectedError[prop-missing] : Exposed options is a subset of internal
-   * options */
   return [fragmentData, refetch];
 }
 module.exports = useRefetchableFragment;

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;
     },

package/lib/relay-hooks/preloadQuery_DEPRECATED.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"];
@@ -20,10 +9,7 @@ var _require = require('relay-runtime'),
   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 DEFAULT_PREFETCH_TIMEOUT = 30 * 1000;
 var WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
 var STORE_OR_NETWORK_DEFAULT = 'store-or-network';
 var pendingQueriesByEnvironment = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();
@@ -33,7 +19,7 @@ function preloadQuery(environment, preloadableRequest, variables, options, envir
     _pendingQueries = new Map();
     pendingQueriesByEnvironment.set(environment, _pendingQueries);
   }
-  var pendingQueries = _pendingQueries; // store in a const for flow
+  var pendingQueries = _pendingQueries;
   var queryEntry = preloadQueryDeduped(environment, pendingQueries, preloadableRequest, variables, options);
   var source = queryEntry.kind === 'network' ? Observable.create(function (sink) {
     var subscription;
@@ -52,8 +38,6 @@ function preloadQuery(environment, preloadableRequest, variables, options, envir
         return;
       }
       setTimeout(function () {
-        // Clear the cache entry after the default timeout
-        // null-check for Flow
         if (queryEntry != null) {
           cleanup(pendingQueries, queryEntry);
         }
@@ -115,15 +99,12 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
     };
     if (!environment.isServer() && prevQueryEntry == null) {
       setTimeout(function () {
-        // Clear the cache entry after the default timeout
-        // null-check for Flow
         if (nextQueryEntry != null) {
           cleanup(pendingQueries, nextQueryEntry);
         }
       }, DEFAULT_PREFETCH_TIMEOUT);
     }
   } else if (prevQueryEntry == null || prevQueryEntry.kind !== 'network') {
-    // Should fetch but we're not already fetching: fetch!
     var source = network.execute(params, variables, networkCacheConfig, null);
     var subject = new ReplaySubject();
     nextQueryEntry = {
@@ -144,8 +125,6 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
           return;
         }
         setTimeout(function () {
-          // Clear the cache entry after the default timeout
-          // null-check for Flow
           if (nextQueryEntry != null) {
             cleanup(pendingQueries, nextQueryEntry);
           }
@@ -169,10 +148,6 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
   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') {

package/lib/relay-hooks/prepareEntryPoint_DEPRECATED.js

@@ -1,21 +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 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);

package/lib/relay-hooks/useBlockingPaginationFragment.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"];
@@ -34,7 +23,6 @@ function useBlockingPaginationFragment(fragmentInput, parentFragmentRef) {
   useStaticFragmentNodeWarning(fragmentNode, "first argument of ".concat(componentDisplayName));
   var _getPaginationMetadat = getPaginationMetadata(fragmentNode, componentDisplayName),
     connectionPathInFragmentData = _getPaginationMetadat.connectionPathInFragmentData,
-    identifierField = _getPaginationMetadat.identifierField,
     paginationRequest = _getPaginationMetadat.paginationRequest,
     paginationMetadata = _getPaginationMetadat.paginationMetadata,
     stream = _getPaginationMetadat.stream;
@@ -46,8 +34,6 @@ function useBlockingPaginationFragment(fragmentInput, parentFragmentRef) {
     disableStoreUpdates = _useRefetchableFragme.disableStoreUpdates,
     enableStoreUpdates = _useRefetchableFragme.enableStoreUpdates;
   var fragmentIdentifier = getFragmentIdentifier(fragmentNode, fragmentRef);
-
-  // Backward pagination
   var _useLoadMore = useLoadMore({
       componentDisplayName: componentDisplayName,
       connectionPathInFragmentData: connectionPathInFragmentData,
@@ -58,15 +44,12 @@ function useBlockingPaginationFragment(fragmentInput, parentFragmentRef) {
       fragmentIdentifier: fragmentIdentifier,
       fragmentNode: fragmentNode,
       fragmentRef: fragmentRef,
-      identifierField: identifierField,
       paginationMetadata: paginationMetadata,
       paginationRequest: paginationRequest
     }),
     loadPrevious = _useLoadMore[0],
     hasPrevious = _useLoadMore[1],
     disposeFetchPrevious = _useLoadMore[2];
-
-  // Forward pagination
   var _useLoadMore2 = useLoadMore({
       componentDisplayName: componentDisplayName,
       connectionPathInFragmentData: connectionPathInFragmentData,
@@ -77,7 +60,6 @@ function useBlockingPaginationFragment(fragmentInput, parentFragmentRef) {
       fragmentIdentifier: fragmentIdentifier,
       fragmentNode: fragmentNode,
       fragmentRef: fragmentRef,
-      identifierField: identifierField,
       paginationMetadata: paginationMetadata,
       paginationRequest: paginationRequest
     }),
@@ -92,7 +74,6 @@ function useBlockingPaginationFragment(fragmentInput, parentFragmentRef) {
     }));
   }, [disposeFetchNext, disposeFetchPrevious, refetch]);
   return {
-    // $FlowFixMe[incompatible-cast]
     data: fragmentData,
     loadNext: loadNext,
     loadPrevious: loadPrevious,
@@ -121,13 +102,7 @@ function useLoadMore(args) {
   };
   var observer = {
     complete: promiseResolve,
-    // NOTE: loadMore is a no-op if a request is already in flight, so we
-    // can safely assume that `start` will only be called once while a
-    // request is in flight.
     start: function start() {
-      // NOTE: We disable store updates when we suspend to ensure
-      // that higher-pri updates from the Relay store don't disrupt
-      // any Suspense timeouts passed via withSuspenseConfig.
       disableStoreUpdates();
       var promise = new Promise(function (resolve) {
         promiseResolveRef.current = function () {
@@ -138,14 +113,7 @@ function useLoadMore(args) {
       requestPromiseRef.current = promise;
       setRequestPromise(promise);
     },
-    // NOTE: Since streaming is disallowed with this hook, this means that the
-    // first payload will always contain the entire next page of items,
-    // while subsequent paylaods will contain @defer'd payloads.
-    // This allows us to unsuspend here, on the first payload, and allow
-    // descendant components to suspend on their respective @defer payloads
     next: promiseResolve,
-    // TODO: Handle error; we probably don't want to throw an error
-    // and blow away the whole list of items.
     error: promiseResolve
   };
   var _useLoadMoreFunction = useLoadMoreFunction((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, loadMoreArgs), {}, {
@@ -155,23 +123,13 @@ function useLoadMore(args) {
     loadMore = _useLoadMoreFunction[0],
     hasMore = _useLoadMoreFunction[1],
     disposeFetch = _useLoadMoreFunction[2];
-
-  // NOTE: To determine if we need to suspend, we check that the promise in
-  // state is the same as the promise on the ref, which ensures that we
-  // wont incorrectly suspend on other higher-pri updates before the update
-  // to suspend has committed.
   if (requestPromise != null && requestPromise === requestPromiseRef.current) {
     throw requestPromise;
   }
   useEffect(function () {
     if (requestPromise !== requestPromiseRef.current) {
-      // NOTE: After suspense pagination has resolved, we re-enable store updates
-      // for this fragment. This may cause the component to re-render if
-      // we missed any updates to the fragment data other than the pagination update.
       enableStoreUpdates();
     }
-    // NOTE: We know the identity of enableStoreUpdates wont change
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [requestPromise]);
   return [loadMore, hasMore, disposeFetch];
 }

package/lib/relay-hooks/useClientQuery.js

@@ -1,27 +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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var useLazyLoadQuery = require('./useLazyLoadQuery');
-
-/**
- * This hook can be used to render client-only queries.
- * These queries are consist of queries for client-only data,
- * schematized via local schema extensions and/or Relay resolvers.
- */
 function useClientQuery(gqlQuery, variables, options) {
-  // $FlowFixMe[incompatible-type] client queries can be used with useLazyLoadQuery, but only with `store-only` policy.
   var query = gqlQuery;
   return useLazyLoadQuery(query, variables, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, options), {}, {
     fetchPolicy: 'store-only'

package/lib/relay-hooks/useEntryPointLoader.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"];
@@ -27,26 +16,6 @@ var initialNullEntryPointReferenceState = {
 };
 function useLoadEntryPoint(environmentProvider, entryPoint, options) {
   var _options$TEST_ONLY__i, _options$TEST_ONLY__i2, _options$TEST_ONLY__i3, _options$TEST_ONLY__i4;
-  /**
-   * We want to always call `entryPointReference.dispose()` for every call to
-   * `setEntryPointReference(loadEntryPoint(...))` so that no leaks of data in Relay
-   * stores will occur.
-   *
-   * However, a call to `setState(newState)` is not always followed by a commit where
-   * this value is reflected in the state. Thus, we cannot reliably clean up each ref
-   * with `useEffect(() => () => entryPointReference.dispose(), [entryPointReference])`.
-   *
-   * Instead, we keep track of each call to `loadEntryPoint` in a ref.
-   * Relying on the fact that if a state change commits, no state changes that were
-   * initiated prior to the currently committing state change will ever subsequently
-   * commit, we can safely dispose of all preloaded entry point references
-   * associated with state changes initiated prior to the currently committing state
-   * change.
-   *
-   * Finally, when the hook unmounts, we also dispose of all remaining uncommitted
-   * entry point references.
-   */
-
   useTrackLoadQueryInRender();
   var initialEntryPointReferenceInternal = (_options$TEST_ONLY__i = options === null || options === void 0 ? void 0 : (_options$TEST_ONLY__i2 = options.TEST_ONLY__initialEntryPointData) === null || _options$TEST_ONLY__i2 === void 0 ? void 0 : _options$TEST_ONLY__i2.entryPointReference) !== null && _options$TEST_ONLY__i !== void 0 ? _options$TEST_ONLY__i : initialNullEntryPointReferenceState;
   var initialEntryPointParamsInternal = (_options$TEST_ONLY__i3 = options === null || options === void 0 ? void 0 : (_options$TEST_ONLY__i4 = options.TEST_ONLY__initialEntryPointData) === null || _options$TEST_ONLY__i4 === void 0 ? void 0 : _options$TEST_ONLY__i4.entryPointParams) !== null && _options$TEST_ONLY__i3 !== void 0 ? _options$TEST_ONLY__i3 : null;
@@ -78,53 +47,17 @@ function useLoadEntryPoint(environmentProvider, entryPoint, options) {
   var maybeHiddenOrFastRefresh = useRef(false);
   useEffect(function () {
     return function () {
-      // Attempt to detect if the component was
-      // hidden (by Offscreen API), or fast refresh occured;
-      // Only in these situations would the effect cleanup
-      // for "unmounting" run multiple times, so if
-      // we are ever able to read this ref with a value
-      // of true, it means that one of these cases
-      // has happened.
       maybeHiddenOrFastRefresh.current = true;
     };
   }, []);
   useEffect(function () {
     if (maybeHiddenOrFastRefresh.current === 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 entryPointReference will have been disposed
-      // by the previous cleanup, so instead of attempting to
-      // do our regular commit setup, which would incorrectly leave our
-      // current entryPointReference disposed, we need to load the entryPoint again
-      // and force a re-render by calling entryPointLoaderCallback again,
-      // so that the entryPointReference's queries are correctly re-retained, and
-      // potentially refetched if necessary.
       maybeHiddenOrFastRefresh.current = false;
       if (entryPointReference.kind !== 'NullEntryPointReference' && entryPointParams != null) {
         entryPointLoaderCallback(entryPointParams);
       }
       return;
     }
-
-    // When a new entryPointReference is committed, we iterate over all
-    // entrypoint refs in undisposedEntryPointReferences and dispose all of
-    // the refs that aren't the currently committed one. This ensures
-    // that we don't leave any dangling entrypoint references for the
-    // case that loadEntryPoint is called multiple times before commit; when
-    // this happens, multiple state updates will be scheduled, but only one
-    // will commit, meaning that we need to keep track of and dispose any
-    // query references that don't end up committing.
-    // - We are relying on the fact that sets iterate in insertion order, and we
-    // can remove items from a set as we iterate over it (i.e. no iterator
-    // invalidation issues.) Thus, it is safe to loop through
-    // undisposedEntryPointReferences until we find entryPointReference, and
-    // remove and dispose all previous references.
-    // - We are guaranteed to find entryPointReference in the set, because if a
-    // state change results in a commit, no state changes initiated prior to that
-    // one will be committed, and we are disposing and removing references
-    // associated with commits that were initiated prior to the currently
-    // committing state change. (A useEffect callback is called during the commit
-    // phase.)
     var undisposedEntryPointReferences = undisposedEntryPointReferencesRef.current;
     if (isMountedRef.current) {
       var _iterator = (0, _createForOfIteratorHelper2["default"])(undisposedEntryPointReferences),
@@ -149,8 +82,6 @@ function useLoadEntryPoint(environmentProvider, entryPoint, options) {
   }, [entryPointReference, entryPointParams, entryPointLoaderCallback, isMountedRef]);
   useEffect(function () {
     return function disposeAllRemainingEntryPointReferences() {
-      // undisposedEntryPointReferences.current is never reassigned
-      // eslint-disable-next-line react-hooks/exhaustive-deps
       var _iterator2 = (0, _createForOfIteratorHelper2["default"])(undisposedEntryPointReferencesRef.current),
         _step2;
       try {

package/lib/relay-hooks/useFetchTrackingRef.js

@@ -1,33 +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 useUnsafeRef_DEPRECATED = require('./useUnsafeRef_DEPRECATED');
 var _require = require('react'),
   useCallback = _require.useCallback,
   useEffect = _require.useEffect;
-
-/**
- * This hook returns a mutable React ref that holds the value of whether a
- * fetch request is in flight. The reason this is a mutable ref instead of
- * state is because we don't actually want to trigger an update when this
- * changes, but instead synchronously keep track of whether the network request
- * is in flight, for example in order to bail out of a request if one is
- * already in flight. If this was state, due to the nature of concurrent
- * updates, this value wouldn't be in sync with when the request is actually
- * in flight.
- * The additional functions returned by this Hook can be used to mutate
- * the ref.
- */
 function useFetchTrackingRef() {
   var subscriptionRef = useUnsafeRef_DEPRECATED(null);
   var isFetchingRef = useUnsafeRef_DEPRECATED(false);
@@ -46,8 +22,6 @@ function useFetchTrackingRef() {
     subscriptionRef.current = null;
     isFetchingRef.current = false;
   }, []);
-
-  // Dipose of ongoing fetch on unmount
   useEffect(function () {
     return disposeFetch;
   }, [disposeFetch]);