react-relay 0.0.0-main-7207485b → 0.0.0-main-d2d2d1f2

package/ReactRelayContext.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-7207485b
+ * Relay v0.0.0-main-d2d2d1f2
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/hooks.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-7207485b
+ * Relay v0.0.0-main-d2d2d1f2
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-7207485b
+ * Relay v0.0.0-main-d2d2d1f2
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/legacy.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-7207485b
+ * Relay v0.0.0-main-d2d2d1f2
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

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

@@ -0,0 +1,37 @@
+/**
+ * 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
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var invariant = require('invariant'); // $FlowFixMe[prop-missing] These exist in experimental builds but aren't in React's types yet.
+
+
+var _require = require('react'),
+    unstable_getCacheForType = _require.unstable_getCacheForType,
+    unstable_getCacheSignal = _require.unstable_getCacheSignal;
+
+var _require2 = require('relay-runtime'),
+    RelayFeatureFlags = _require2.RelayFeatureFlags;
+
+function getCacheForType(factory) {
+  !(typeof unstable_getCacheForType === 'function' && RelayFeatureFlags.USE_REACT_CACHE) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReactCache.getCacheForType should only be called when the USE_REACT_CACHE feature flag is enabled and when on an experimental React build that supports it.') : invariant(false) : void 0;
+  return unstable_getCacheForType(factory);
+}
+
+function getCacheSignal() {
+  !(typeof unstable_getCacheSignal === 'function' && RelayFeatureFlags.USE_REACT_CACHE) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReactCache.getCacheSignal should only be called when the USE_REACT_CACHE feature flag is enabled and when on an experimental React build that supports it.') : invariant(false) : void 0;
+  return unstable_getCacheSignal();
+}
+
+module.exports = {
+  getCacheForType: getCacheForType,
+  getCacheSignal: getCacheSignal
+};

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

@@ -0,0 +1,197 @@
+/**
+ * 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
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _require = require('./RelayReactCache'),
+    getCacheForType = _require.getCacheForType,
+    getCacheSignal = _require.getCacheSignal;
+
+var invariant = require('invariant');
+
+var _require2 = require('relay-runtime'),
+    fetchQueryInternal = _require2.__internal.fetchQuery;
+
+var warning = require("fbjs/lib/warning");
+
+var DEFAULT_FETCH_POLICY = 'store-or-network';
+
+function createQueryCache() {
+  return new Map();
+}
+
+function getQueryCacheKey(operation, fetchPolicy, renderPolicy) {
+  var cacheIdentifier = "".concat(fetchPolicy, "-").concat(renderPolicy, "-").concat(operation.request.identifier);
+  return cacheIdentifier;
+}
+
+function constructQueryResult(operation) {
+  var rootFragmentRef = {
+    __id: operation.fragment.dataID,
+    __fragments: (0, _defineProperty2["default"])({}, operation.fragment.node.name, operation.request.variables),
+    __fragmentOwner: operation.request
+  };
+  return {
+    fragmentNode: operation.request.node.fragment,
+    fragmentRef: rootFragmentRef
+  };
+}
+
+function getQueryResultOrFetchQuery_REACT_CACHE(environment, queryOperationDescriptor) {
+  var fetchPolicy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_FETCH_POLICY;
+  var maybeRenderPolicy = arguments.length > 3 ? arguments[3] : undefined;
+  var renderPolicy = maybeRenderPolicy !== null && maybeRenderPolicy !== void 0 ? maybeRenderPolicy : environment.UNSTABLE_getDefaultRenderPolicy();
+  var cache = getCacheForType(createQueryCache);
+  var cacheKey = getQueryCacheKey(queryOperationDescriptor, fetchPolicy, renderPolicy);
+  var entry = cache.get(cacheKey);
+
+  if (entry === undefined) {
+    // Initiate a query to fetch the data if needed:
+    entry = onCacheMiss(environment, queryOperationDescriptor, fetchPolicy, renderPolicy, function (newCacheEntry) {
+      cache.set(cacheKey, newCacheEntry);
+    });
+    cache.set(cacheKey, entry); // Since this is the first time rendering, retain the query. React will
+    // trigger the abort signal when this cache entry is no longer needed.
+
+    var retention = environment.retain(queryOperationDescriptor);
+    var abortSignal = getCacheSignal();
+    abortSignal.addEventListener('abort', function () {
+      retention.dispose();
+      cache["delete"](cacheKey);
+    }, {
+      once: true
+    });
+  }
+
+  switch (entry.status) {
+    case 'pending':
+      throw entry.promise;
+
+    case 'rejected':
+      throw entry.error;
+
+    case 'resolved':
+      return entry.result;
+  }
+
+  !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'switch statement should be exhaustive') : invariant(false) : void 0;
+}
+
+function onCacheMiss(environment, operation, fetchPolicy, renderPolicy, updateCache) {
+  // NB: Besides checking if the data is available, calling `check` will write missing
+  // data to the store using any missing data handlers specified in the environment.
+  var queryAvailability = environment.check(operation);
+  var queryStatus = queryAvailability.status;
+  var hasFullQuery = queryStatus === 'available';
+  var canPartialRender = hasFullQuery || renderPolicy === 'partial' && queryStatus !== 'stale';
+  var shouldFetch;
+  var shouldRenderNow;
+
+  switch (fetchPolicy) {
+    case 'store-only':
+      {
+        shouldFetch = false;
+        shouldRenderNow = true;
+        break;
+      }
+
+    case 'store-or-network':
+      {
+        shouldFetch = !hasFullQuery;
+        shouldRenderNow = canPartialRender;
+        break;
+      }
+
+    case 'store-and-network':
+      {
+        shouldFetch = true;
+        shouldRenderNow = canPartialRender;
+        break;
+      }
+
+    case 'network-only':
+    default:
+      {
+        shouldFetch = true;
+        shouldRenderNow = false;
+        break;
+      }
+  }
+
+  var promise = shouldFetch ? executeOperationAndKeepUpToDate(environment, operation, updateCache) : undefined;
+
+  if (shouldRenderNow) {
+    return {
+      status: 'resolved',
+      result: constructQueryResult(operation)
+    };
+  } else {
+    !promise ? process.env.NODE_ENV !== "production" ? invariant(false, 'Should either fetch or render (or both), otherwise we would suspend forever.') : invariant(false) : void 0;
+    return {
+      status: 'pending',
+      promise: promise
+    };
+  }
+}
+
+function executeOperationAndKeepUpToDate(environment, operation, updateCache) {
+  var resolvePromise;
+  var promise = new Promise(function (r) {
+    resolvePromise = r;
+  }); // $FlowExpectedError[prop-missing] Expando to annotate Promises.
+
+  promise.displayName = 'Relay(' + operation.request.node.operation.name + ')';
+  var isFirstPayload = true; // FIXME We may still need to cancel network requests for live queries.
+
+  var fetchObservable = fetchQueryInternal(environment, operation);
+  fetchObservable.subscribe({
+    start: function start(subscription) {},
+    error: function error(_error) {
+      if (isFirstPayload) {
+        updateCache({
+          status: 'rejected',
+          error: _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, 'getQueryResultOrFetchQuery: An incremental payload for query `%` returned an error: `%`:`%`.', operation.request.node.operation.name, _error.message, _error.stack) : void 0;
+      }
+
+      resolvePromise();
+      isFirstPayload = false;
+    },
+    next: function next(response) {
+      // Stop suspending on the first payload because of streaming, defer, etc.
+      updateCache({
+        status: 'resolved',
+        result: constructQueryResult(operation)
+      });
+      resolvePromise();
+      isFirstPayload = false;
+    },
+    complete: function complete() {
+      updateCache({
+        status: 'resolved',
+        result: constructQueryResult(operation)
+      });
+      resolvePromise();
+      isFirstPayload = false;
+    }
+  });
+  return promise;
+}
+
+module.exports = getQueryResultOrFetchQuery_REACT_CACHE;

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

@@ -0,0 +1,400 @@
+/**
+ * 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
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+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 useRelayEnvironment = require('../useRelayEnvironment');
+
+var getQueryResultOrFetchQuery = require('./getQueryResultOrFetchQuery_REACT_CACHE');
+
+var invariant = require('invariant');
+
+var _require = require('react'),
+    useDebugValue = _require.useDebugValue,
+    useEffect = _require.useEffect,
+    useMemo = _require.useMemo,
+    useRef = _require.useRef,
+    useState = _require.useState;
+
+var _require2 = require('relay-runtime'),
+    areEqualSelectors = _require2.areEqualSelectors,
+    createOperationDescriptor = _require2.createOperationDescriptor,
+    getPendingOperationsForFragment = _require2.getPendingOperationsForFragment,
+    getSelector = _require2.getSelector,
+    getVariablesFromFragment = _require2.getVariablesFromFragment,
+    recycleNodesInto = _require2.recycleNodesInto,
+    reportMissingRequiredFields = _require2.reportMissingRequiredFields;
+
+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 reportMissingRequiredFieldsForState(environment, state) {
+  if (state.kind === 'singular') {
+    if (state.snapshot.missingRequiredFields != null) {
+      reportMissingRequiredFields(environment, state.snapshot.missingRequiredFields);
+    }
+  } else if (state.kind === 'plural') {
+    var _iterator3 = (0, _createForOfIteratorHelper2["default"])(state.snapshots),
+        _step3;
+
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var snapshot = _step3.value;
+
+        if (snapshot.missingRequiredFields != null) {
+          reportMissingRequiredFields(environment, snapshot.missingRequiredFields);
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  }
+}
+
+function handleMissedUpdates(environment, state, setState) {
+  if (state.kind === 'bailout') {
+    return;
+  }
+
+  var currentEpoch = environment.getStore().getEpoch();
+
+  if (currentEpoch === state.epoch) {
+    return;
+  } // 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);
+
+    if (updatedData !== state.snapshot.data) {
+      setState({
+        kind: 'singular',
+        snapshot: currentSnapshot,
+        epoch: currentEpoch
+      });
+    }
+  } else {
+    var updates = null;
+
+    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);
+
+      if (_updatedData !== snapshot.data) {
+        updates = updates === null ? new Array(state.snapshots.length) : updates;
+        updates[index] = snapshot;
+      }
+    }
+
+    if (updates !== null) {
+      var theUpdates = updates; // preserve flow refinement.
+
+      setState(function (existing) {
+        !(existing.kind === 'plural') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Cannot go from singular to plural or from bailout to plural.') : invariant(false) : void 0;
+        var updated = (0, _toConsumableArray2["default"])(existing.snapshots);
+
+        for (var _index = 0; _index < theUpdates.length; _index++) {
+          var updatedSnapshot = theUpdates[_index];
+
+          if (updatedSnapshot) {
+            updated[_index] = updatedSnapshot;
+          }
+        }
+
+        return {
+          kind: 'plural',
+          snapshots: updated,
+          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; getQueryResultOrFetchQuery
+  // already handles this by itself.
+
+  getQueryResultOrFetchQuery(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({
+        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 (existing) {
+          !(existing.kind === 'plural') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Cannot go from singular to plural or from bailout to plural.') : invariant(false) : void 0;
+          var updated = (0, _toConsumableArray2["default"])(existing.snapshots);
+          updated[index] = latestSnapshot;
+          return {
+            kind: 'plural',
+            snapshots: updated,
+            epoch: environment.getStore().getEpoch()
+          };
+        });
+      });
+    });
+    return function () {
+      var _iterator4 = (0, _createForOfIteratorHelper2["default"])(disposables),
+          _step4;
+
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var d = _step4.value;
+          d.dispose();
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    };
+  }
+}
+
+function getFragmentState(environment, fragmentSelector) {
+  if (fragmentSelector == null) {
+    return {
+      kind: 'bailout'
+    };
+  } else if (fragmentSelector.kind === 'PluralReaderSelector') {
+    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;
+
+  var fragmentSelector = getSelector(fragmentNode, fragmentRef);
+
+  if ((fragmentNode === null || fragmentNode === void 0 ? void 0 : (_fragmentNode$metadat = fragmentNode.metadata) === null || _fragmentNode$metadat === void 0 ? void 0 : _fragmentNode$metadat.plural) === true) {
+    !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 || 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);
+  }),
+      rawState = _useState[0],
+      setState = _useState[1];
+
+  var _useState2 = useState(fragmentSelector),
+      previousFragmentSelector = _useState2[0],
+      setPreviousFragmentSelector = _useState2[1];
+
+  if (!areEqualSelectors(fragmentSelector, previousFragmentSelector)) {
+    setPreviousFragmentSelector(fragmentSelector);
+    setState(getFragmentState(environment, fragmentSelector));
+  }
+
+  var state;
+
+  if (fragmentRef == null) {
+    state = {
+      kind: 'bailout'
+    };
+  } else if (rawState.kind === 'plural' && rawState.snapshots.length === 0) {
+    state = {
+      kind: 'bailout'
+    };
+  } else {
+    state = rawState;
+  } // Handle the queries for any missing client edges; this may suspend.
+  // FIXME handle client edges in parallel.
+
+
+  var missingClientEdges = getMissingClientEdges(state);
+
+  if (missingClientEdges === null || missingClientEdges === void 0 ? void 0 : missingClientEdges.length) {
+    var _iterator5 = (0, _createForOfIteratorHelper2["default"])(missingClientEdges),
+        _step5;
+
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var edge = _step5.value;
+        handleMissingClientEdge(environment, fragmentNode, fragmentRef, edge, queryOptions);
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+  }
+
+  if (isMissingData(state)) {
+    // Suspend if an active operation bears on this fragment, either the
+    // fragment's owner or some other mutation etc. that could affect it:
+    !(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:
+
+
+    reportMissingRequiredFieldsForState(environment, state);
+  } // Subscriptions:
+
+
+  var isMountedRef = useRef(false);
+  var isListeningForUpdatesRef = useRef(true);
+
+  function enableStoreUpdates() {
+    isListeningForUpdatesRef.current = true;
+    handleMissedUpdates(environment, state, setState);
+  }
+
+  function disableStoreUpdates() {
+    isListeningForUpdatesRef.current = false;
+  }
+
+  useEffect(function () {
+    var wasAlreadySubscribed = isMountedRef.current;
+    isMountedRef.current = true;
+
+    if (!wasAlreadySubscribed) {
+      handleMissedUpdates(environment, state, setState);
+    }
+
+    return subscribeToSnapshot(environment, state, setState);
+  }, [environment, state]);
+  var data = useMemo(function () {
+    return state.kind === 'bailout' ? {} : state.kind === 'singular' ? state.snapshot.data : state.snapshots.map(function (s) {
+      return s.data;
+    });
+  }, [state]);
+
+  if (process.env.NODE_ENV !== "production") {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useDebugValue({
+      fragment: fragmentNode.name,
+      data: data
+    });
+  }
+
+  return {
+    data: data,
+    disableStoreUpdates: disableStoreUpdates,
+    enableStoreUpdates: enableStoreUpdates
+  };
+}
+
+module.exports = useFragmentInternal_REACT_CACHE;