react-relay 13.1.1 → 14.1.0

package/lib/relay-hooks/react-cache/useFragmentInternal_REACT_CACHE.js

@@ -0,0 +1,598 @@
+/**
+ * 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.
+ *
+ * 
+ * @emails oncall+relay
+ * @format
+ */
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _require = require('../QueryResource'),
+    getQueryResourceForEnvironment = _require.getQueryResourceForEnvironment;
+
+var useRelayEnvironment = require('../useRelayEnvironment');
+
+var invariant = require('invariant');
+
+var _require2 = require('react'),
+    useDebugValue = _require2.useDebugValue,
+    useEffect = _require2.useEffect,
+    useMemo = _require2.useMemo,
+    useRef = _require2.useRef,
+    useState = _require2.useState;
+
+var _require3 = require('relay-runtime'),
+    fetchQueryInternal = _require3.__internal.fetchQuery,
+    areEqualSelectors = _require3.areEqualSelectors,
+    createOperationDescriptor = _require3.createOperationDescriptor,
+    getPendingOperationsForFragment = _require3.getPendingOperationsForFragment,
+    getSelector = _require3.getSelector,
+    getVariablesFromFragment = _require3.getVariablesFromFragment,
+    handlePotentialSnapshotErrors = _require3.handlePotentialSnapshotErrors,
+    recycleNodesInto = _require3.recycleNodesInto;
+
+var warning = require("fbjs/lib/warning");
+
+function isMissingData(state) {
+  if (state.kind === 'bailout') {
+    return false;
+  } else if (state.kind === 'singular') {
+    return state.snapshot.isMissingData;
+  } else {
+    return state.snapshots.some(function (s) {
+      return s.isMissingData;
+    });
+  }
+}
+
+function getMissingClientEdges(state) {
+  if (state.kind === 'bailout') {
+    return null;
+  } else if (state.kind === 'singular') {
+    var _state$snapshot$missi;
+
+    return (_state$snapshot$missi = state.snapshot.missingClientEdges) !== null && _state$snapshot$missi !== void 0 ? _state$snapshot$missi : null;
+  } else {
+    var edges = null;
+
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(state.snapshots),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var snapshot = _step.value;
+
+        if (snapshot.missingClientEdges) {
+          var _edges;
+
+          edges = (_edges = edges) !== null && _edges !== void 0 ? _edges : [];
+
+          var _iterator2 = (0, _createForOfIteratorHelper2["default"])(snapshot.missingClientEdges),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var edge = _step2.value;
+              edges.push(edge);
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return edges;
+  }
+}
+
+function getSuspendingLiveResolver(state) {
+  if (state.kind === 'bailout') {
+    return null;
+  } else if (state.kind === 'singular') {
+    var _state$snapshot$missi2;
+
+    return (_state$snapshot$missi2 = state.snapshot.missingLiveResolverFields) !== null && _state$snapshot$missi2 !== void 0 ? _state$snapshot$missi2 : null;
+  } else {
+    var missingFields = null;
+
+    var _iterator3 = (0, _createForOfIteratorHelper2["default"])(state.snapshots),
+        _step3;
+
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var snapshot = _step3.value;
+
+        if (snapshot.missingLiveResolverFields) {
+          var _missingFields;
+
+          missingFields = (_missingFields = missingFields) !== null && _missingFields !== void 0 ? _missingFields : [];
+
+          var _iterator4 = (0, _createForOfIteratorHelper2["default"])(snapshot.missingLiveResolverFields),
+              _step4;
+
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var edge = _step4.value;
+              missingFields.push(edge);
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+
+    return missingFields;
+  }
+}
+
+function handlePotentialSnapshotErrorsForState(environment, state) {
+  if (state.kind === 'singular') {
+    handlePotentialSnapshotErrors(environment, state.snapshot.missingRequiredFields, state.snapshot.relayResolverErrors);
+  } else if (state.kind === 'plural') {
+    var _iterator5 = (0, _createForOfIteratorHelper2["default"])(state.snapshots),
+        _step5;
+
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var snapshot = _step5.value;
+        handlePotentialSnapshotErrors(environment, snapshot.missingRequiredFields, snapshot.relayResolverErrors);
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+  }
+}
+/**
+ * Check for updates to the store that occurred concurrently with rendering the given `state` value,
+ * returning a new (updated) state if there were updates or null if there were no changes.
+ */
+
+
+function handleMissedUpdates(environment, state) {
+  if (state.kind === 'bailout') {
+    return null;
+  } // FIXME this is invalid if we've just switched environments.
+
+
+  var currentEpoch = environment.getStore().getEpoch();
+
+  if (currentEpoch === state.epoch) {
+    return null;
+  } // The store has updated since we rendered (without us being subscribed yet),
+  // so check for any updates to the data we're rendering:
+
+
+  if (state.kind === 'singular') {
+    var currentSnapshot = environment.lookup(state.snapshot.selector);
+    var updatedData = recycleNodesInto(state.snapshot.data, currentSnapshot.data);
+    var updatedCurrentSnapshot = {
+      data: updatedData,
+      isMissingData: currentSnapshot.isMissingData,
+      missingClientEdges: currentSnapshot.missingClientEdges,
+      missingLiveResolverFields: currentSnapshot.missingLiveResolverFields,
+      seenRecords: currentSnapshot.seenRecords,
+      selector: currentSnapshot.selector,
+      missingRequiredFields: currentSnapshot.missingRequiredFields,
+      relayResolverErrors: currentSnapshot.relayResolverErrors
+    };
+    return [updatedData !== state.snapshot.data, {
+      kind: 'singular',
+      snapshot: updatedCurrentSnapshot,
+      epoch: currentEpoch
+    }];
+  } else {
+    var didMissUpdates = false;
+    var currentSnapshots = [];
+
+    for (var index = 0; index < state.snapshots.length; index++) {
+      var snapshot = state.snapshots[index];
+
+      var _currentSnapshot = environment.lookup(snapshot.selector);
+
+      var _updatedData = recycleNodesInto(snapshot.data, _currentSnapshot.data);
+
+      var _updatedCurrentSnapshot = {
+        data: _updatedData,
+        isMissingData: _currentSnapshot.isMissingData,
+        missingClientEdges: _currentSnapshot.missingClientEdges,
+        missingLiveResolverFields: _currentSnapshot.missingLiveResolverFields,
+        seenRecords: _currentSnapshot.seenRecords,
+        selector: _currentSnapshot.selector,
+        missingRequiredFields: _currentSnapshot.missingRequiredFields,
+        relayResolverErrors: _currentSnapshot.relayResolverErrors
+      };
+
+      if (_updatedData !== snapshot.data) {
+        didMissUpdates = true;
+      }
+
+      currentSnapshots.push(_updatedCurrentSnapshot);
+    }
+
+    !(currentSnapshots.length === state.snapshots.length) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected same number of snapshots') : invariant(false) : void 0;
+    return [didMissUpdates, {
+      kind: 'plural',
+      snapshots: currentSnapshots,
+      epoch: currentEpoch
+    }];
+  }
+}
+
+function handleMissingClientEdge(environment, parentFragmentNode, parentFragmentRef, missingClientEdgeRequestInfo, queryOptions) {
+  var originalVariables = getVariablesFromFragment(parentFragmentNode, parentFragmentRef);
+  var variables = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, originalVariables), {}, {
+    id: missingClientEdgeRequestInfo.clientEdgeDestinationID // TODO should be a reserved name
+
+  });
+  var queryOperationDescriptor = createOperationDescriptor(missingClientEdgeRequestInfo.request, variables, queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.networkCacheConfig); // This may suspend. We don't need to do anything with the results; all we're
+  // doing here is started the query if needed and retaining and releasing it
+  // according to the component mount/suspense cycle; QueryResource
+  // already handles this by itself.
+
+  var QueryResource = getQueryResourceForEnvironment(environment);
+  return QueryResource.prepare(queryOperationDescriptor, fetchQueryInternal(environment, queryOperationDescriptor), queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.fetchPolicy);
+}
+
+function subscribeToSnapshot(environment, state, setState) {
+  if (state.kind === 'bailout') {
+    return function () {};
+  } else if (state.kind === 'singular') {
+    var disposable = environment.subscribe(state.snapshot, function (latestSnapshot) {
+      setState(function (prevState) {
+        // In theory a setState from a subscription could be batched together
+        // with a setState to change the fragment selector. Guard against this
+        // by bailing out of the state update if the selector has changed.
+        if (prevState.kind !== 'singular' || prevState.snapshot.selector !== latestSnapshot.selector) {
+          return prevState;
+        }
+
+        return {
+          kind: 'singular',
+          snapshot: latestSnapshot,
+          epoch: environment.getStore().getEpoch()
+        };
+      });
+    });
+    return function () {
+      disposable.dispose();
+    };
+  } else {
+    var disposables = state.snapshots.map(function (snapshot, index) {
+      return environment.subscribe(snapshot, function (latestSnapshot) {
+        setState(function (prevState) {
+          var _prevState$snapshots$;
+
+          // In theory a setState from a subscription could be batched together
+          // with a setState to change the fragment selector. Guard against this
+          // by bailing out of the state update if the selector has changed.
+          if (prevState.kind !== 'plural' || ((_prevState$snapshots$ = prevState.snapshots[index]) === null || _prevState$snapshots$ === void 0 ? void 0 : _prevState$snapshots$.selector) !== latestSnapshot.selector) {
+            return prevState;
+          }
+
+          var updated = (0, _toConsumableArray2["default"])(prevState.snapshots);
+          updated[index] = latestSnapshot;
+          return {
+            kind: 'plural',
+            snapshots: updated,
+            epoch: environment.getStore().getEpoch()
+          };
+        });
+      });
+    });
+    return function () {
+      var _iterator6 = (0, _createForOfIteratorHelper2["default"])(disposables),
+          _step6;
+
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var d = _step6.value;
+          d.dispose();
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+    };
+  }
+}
+
+function getFragmentState(environment, fragmentSelector) {
+  if (fragmentSelector == null) {
+    return {
+      kind: 'bailout'
+    };
+  } else if (fragmentSelector.kind === 'PluralReaderSelector') {
+    // Note that if fragmentRef is an empty array, fragmentSelector will be null so we'll hit the above case.
+    // Null is returned by getSelector if fragmentRef has no non-null items.
+    return {
+      kind: 'plural',
+      snapshots: fragmentSelector.selectors.map(function (s) {
+        return environment.lookup(s);
+      }),
+      epoch: environment.getStore().getEpoch()
+    };
+  } else {
+    return {
+      kind: 'singular',
+      snapshot: environment.lookup(fragmentSelector),
+      epoch: environment.getStore().getEpoch()
+    };
+  }
+} // fragmentNode cannot change during the lifetime of the component, though fragmentRef may change.
+
+
+function useFragmentInternal_REACT_CACHE(fragmentNode, fragmentRef, hookDisplayName, queryOptions, fragmentKey) {
+  var _fragmentNode$metadat, _fragmentNode$metadat2;
+
+  var fragmentSelector = useMemo(function () {
+    return getSelector(fragmentNode, fragmentRef);
+  }, [fragmentNode, fragmentRef]);
+  var isPlural = (fragmentNode === null || fragmentNode === void 0 ? void 0 : (_fragmentNode$metadat = fragmentNode.metadata) === null || _fragmentNode$metadat === void 0 ? void 0 : _fragmentNode$metadat.plural) === true;
+
+  if (isPlural) {
+    !(fragmentRef == null || Array.isArray(fragmentRef)) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Relay: Expected fragment pointer%s for fragment `%s` to be ' + 'an array, instead got `%s`. Remove `@relay(plural: true)` ' + 'from fragment `%s` to allow the prop to be an object.', fragmentKey != null ? " for key `".concat(fragmentKey, "`") : '', fragmentNode.name, typeof fragmentRef, fragmentNode.name) : invariant(false) : void 0;
+  } else {
+    !!Array.isArray(fragmentRef) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Relay: Expected fragment pointer%s for fragment `%s` not to be ' + 'an array, instead got `%s`. Add `@relay(plural: true)` ' + 'to fragment `%s` to allow the prop to be an array.', fragmentKey != null ? " for key `".concat(fragmentKey, "`") : '', fragmentNode.name, typeof fragmentRef, fragmentNode.name) : invariant(false) : void 0;
+  }
+
+  !(fragmentRef == null || isPlural && Array.isArray(fragmentRef) && fragmentRef.length === 0 || fragmentSelector != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Relay: Expected to receive an object where `...%s` was spread, ' + 'but the fragment reference was not found`. This is most ' + 'likely the result of:\n' + "- Forgetting to spread `%s` in `%s`'s parent's fragment.\n" + '- Conditionally fetching `%s` but unconditionally passing %s prop ' + 'to `%s`. If the parent fragment only fetches the fragment conditionally ' + '- with e.g. `@include`, `@skip`, or inside a `... on SomeType { }` ' + 'spread  - then the fragment reference will not exist. ' + 'In this case, pass `null` if the conditions for evaluating the ' + 'fragment are not met (e.g. if the `@include(if)` value is false.)', fragmentNode.name, fragmentNode.name, hookDisplayName, fragmentNode.name, fragmentKey == null ? 'a fragment reference' : "the `".concat(fragmentKey, "`"), hookDisplayName) : invariant(false) : void 0;
+  var environment = useRelayEnvironment();
+
+  var _useState = useState(function () {
+    return getFragmentState(environment, fragmentSelector);
+  }),
+      _state = _useState[0],
+      setState = _useState[1];
+
+  var state = _state; // This copy of the state we only update when something requires us to
+  // unsubscribe and re-subscribe, namely a changed environment or
+  // fragment selector.
+
+  var _useState2 = useState(state),
+      _subscribedState = _useState2[0],
+      setSubscribedState = _useState2[1]; // FIXME since this is used as an effect dependency, it needs to be memoized.
+
+
+  var subscribedState = _subscribedState;
+
+  var _useState3 = useState(fragmentSelector),
+      previousFragmentSelector = _useState3[0],
+      setPreviousFragmentSelector = _useState3[1];
+
+  var _useState4 = useState(environment),
+      previousEnvironment = _useState4[0],
+      setPreviousEnvironment = _useState4[1];
+
+  if (!areEqualSelectors(fragmentSelector, previousFragmentSelector) || environment !== previousEnvironment) {
+    // Enqueue setState to record the new selector and state
+    setPreviousFragmentSelector(fragmentSelector);
+    setPreviousEnvironment(environment);
+    var newState = getFragmentState(environment, fragmentSelector);
+    setState(newState);
+    setSubscribedState(newState); // This causes us to form a new subscription
+    // But render with the latest state w/o waiting for the setState. Otherwise
+    // the component would render the wrong information temporarily (including
+    // possibly incorrectly triggering some warnings below).
+
+    state = newState;
+    subscribedState = newState;
+  } // The purpose of this is to detect whether we have ever committed, because we
+  // don't suspend on store updates, only when the component either is first trying
+  // to mount or when the our selector changes. The selector change in particular is
+  // how we suspend for pagination and refetech. Also, fragment selector can be null
+  // or undefined, so we use false as a special value to distinguish from all fragment
+  // selectors; false means that the component hasn't mounted yet.
+
+
+  var committedFragmentSelectorRef = useRef(false);
+  useEffect(function () {
+    committedFragmentSelectorRef.current = fragmentSelector;
+  }, [fragmentSelector]); // Handle the queries for any missing client edges; this may suspend.
+  // FIXME handle client edges in parallel.
+
+  if (((_fragmentNode$metadat2 = fragmentNode.metadata) === null || _fragmentNode$metadat2 === void 0 ? void 0 : _fragmentNode$metadat2.hasClientEdges) === true) {
+    // The fragment is validated to be static (in useFragment) and hasClientEdges is
+    // a static (constant) property of the fragment. In practice, this effect will
+    // always or never run for a given invocation of this hook.
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    var clientEdgeQueries = useMemo(function () {
+      var missingClientEdges = getMissingClientEdges(state); // eslint-disable-next-line no-shadow
+
+      var clientEdgeQueries;
+
+      if (missingClientEdges !== null && missingClientEdges !== void 0 && missingClientEdges.length) {
+        clientEdgeQueries = [];
+
+        var _iterator7 = (0, _createForOfIteratorHelper2["default"])(missingClientEdges),
+            _step7;
+
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var edge = _step7.value;
+            clientEdgeQueries.push(handleMissingClientEdge(environment, fragmentNode, fragmentRef, edge, queryOptions));
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
+      }
+
+      return clientEdgeQueries;
+    }, [state, environment, fragmentNode, fragmentRef, queryOptions]); // See above note
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+
+    useEffect(function () {
+      var QueryResource = getQueryResourceForEnvironment(environment);
+
+      if (clientEdgeQueries !== null && clientEdgeQueries !== void 0 && clientEdgeQueries.length) {
+        var disposables = [];
+
+        var _iterator8 = (0, _createForOfIteratorHelper2["default"])(clientEdgeQueries),
+            _step8;
+
+        try {
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            var query = _step8.value;
+            disposables.push(QueryResource.retain(query));
+          }
+        } catch (err) {
+          _iterator8.e(err);
+        } finally {
+          _iterator8.f();
+        }
+
+        return function () {
+          var _iterator9 = (0, _createForOfIteratorHelper2["default"])(disposables),
+              _step9;
+
+          try {
+            for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+              var disposable = _step9.value;
+              disposable.dispose();
+            }
+          } catch (err) {
+            _iterator9.e(err);
+          } finally {
+            _iterator9.f();
+          }
+        };
+      }
+    }, [environment, clientEdgeQueries]);
+  }
+
+  if (isMissingData(state)) {
+    // Suspend if a Live Resolver within this fragment is in a suspended state:
+    var suspendingLiveResolvers = getSuspendingLiveResolver(state);
+
+    if (suspendingLiveResolvers != null && suspendingLiveResolvers.length > 0) {
+      throw Promise.all(suspendingLiveResolvers.map(function (_ref) {
+        var liveStateID = _ref.liveStateID;
+        // $FlowFixMe[prop-missing] This is expected to be a LiveResolverStore
+        return environment.getStore().getLiveResolverPromise(liveStateID);
+      }));
+    } // Suspend if an active operation bears on this fragment, either the
+    // fragment's owner or some other mutation etc. that could affect it.
+    // We only suspend when the component is first trying to mount or changing
+    // selectors, not if data becomes missing later:
+
+
+    if (!committedFragmentSelectorRef.current || !areEqualSelectors(committedFragmentSelectorRef.current, fragmentSelector)) {
+      !(fragmentSelector != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'refinement, see invariants above') : invariant(false) : void 0;
+      var fragmentOwner = fragmentSelector.kind === 'PluralReaderSelector' ? fragmentSelector.selectors[0].owner : fragmentSelector.owner;
+      var pendingOperationsResult = getPendingOperationsForFragment(environment, fragmentNode, fragmentOwner);
+
+      if (pendingOperationsResult) {
+        throw pendingOperationsResult.promise;
+      }
+    } // Report required fields only if we're not suspending, since that means
+    // they're missing even though we are out of options for possibly fetching them:
+
+
+    handlePotentialSnapshotErrorsForState(environment, state);
+  }
+
+  useEffect(function () {
+    // Check for updates since the state was rendered
+    var currentState = subscribedState;
+    var updates = handleMissedUpdates(environment, subscribedState);
+
+    if (updates !== null) {
+      var didMissUpdates = updates[0],
+          updatedState = updates[1]; // TODO: didMissUpdates only checks for changes to snapshot data, but it's possible
+      // that other snapshot properties may have changed that should also trigger a re-render,
+      // such as changed missing resolver fields, missing client edges, etc.
+      // A potential alternative is for handleMissedUpdates() to recycle the entire state
+      // value, and return the new (recycled) state only if there was some change. In that
+      // case the code would always setState if something in the snapshot changed, in addition
+      // to using the latest snapshot to subscribe.
+
+      if (didMissUpdates) {
+        setState(updatedState);
+      }
+
+      currentState = updatedState;
+    }
+
+    return subscribeToSnapshot(environment, currentState, setState);
+  }, [environment, subscribedState]);
+  var data;
+
+  if (isPlural) {
+    // Plural fragments require allocating an array of the snasphot data values,
+    // which has to be memoized to avoid triggering downstream re-renders.
+    //
+    // Note that isPlural is a constant property of the fragment and does not change
+    // for a particular useFragment invocation site
+    var fragmentRefIsNullish = fragmentRef == null; // for less sensitive memoization
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+
+    data = useMemo(function () {
+      if (state.kind === 'bailout') {
+        // Bailout state can happen if the fragmentRef is a plural array that is empty or has no
+        // non-null entries. In that case, the compatible behavior is to return [] instead of null.
+        return fragmentRefIsNullish ? null : [];
+      } else {
+        !(state.kind === 'plural') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected state to be plural because fragment is plural') : invariant(false) : void 0;
+        return state.snapshots.map(function (s) {
+          return s.data;
+        });
+      }
+    }, [state, fragmentRefIsNullish]);
+  } else if (state.kind === 'bailout') {
+    // This case doesn't allocate a new object so it doesn't have to be memoized
+    data = null;
+  } else {
+    // This case doesn't allocate a new object so it doesn't have to be memoized
+    !(state.kind === 'singular') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected state to be singular because fragment is singular') : invariant(false) : void 0;
+    data = state.snapshot.data;
+  }
+
+  if (process.env.NODE_ENV !== "production") {
+    if (fragmentRef != null && (data === undefined || Array.isArray(data) && data.length > 0 && data.every(function (d) {
+      return d === undefined;
+    }))) {
+      process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Expected to have been able to read non-null data for ' + 'fragment `%s` declared in ' + '`%s`, since fragment reference was non-null. ' + "Make sure that that `%s`'s parent isn't " + 'holding on to and/or passing a fragment reference for data that ' + 'has been deleted.', fragmentNode.name, hookDisplayName, hookDisplayName) : void 0;
+    }
+  }
+
+  if (process.env.NODE_ENV !== "production") {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useDebugValue({
+      fragment: fragmentNode.name,
+      data: data
+    });
+  }
+
+  return data;
+}
+
+module.exports = useFragmentInternal_REACT_CACHE;

package/lib/relay-hooks/react-cache/useFragment_REACT_CACHE.js

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * 
+ * @format
+ */
+'use strict';
+
+var _require = require('../loadQuery'),
+    useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
+
+var useStaticFragmentNodeWarning = require('../useStaticFragmentNodeWarning');
+
+var useFragmentInternal = require('./useFragmentInternal_REACT_CACHE');
+
+var _require2 = require('react'),
+    useDebugValue = _require2.useDebugValue;
+
+var _require3 = require('relay-runtime'),
+    getFragment = _require3.getFragment;
+
+function useFragment(fragment, key) {
+  // We need to use this hook in order to be able to track if
+  // loadQuery was called during render
+  useTrackLoadQueryInRender();
+  var fragmentNode = getFragment(fragment);
+
+  if (process.env.NODE_ENV !== "production") {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useStaticFragmentNodeWarning(fragmentNode, 'first argument of useFragment()');
+  }
+
+  var data = useFragmentInternal(fragmentNode, key, 'useFragment()');
+
+  if (process.env.NODE_ENV !== "production") {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useDebugValue({
+      fragment: fragmentNode.name,
+      data: data
+    });
+  }
+
+  return data;
+}
+
+module.exports = useFragment;