react-relay 16.0.0 → 16.1.0

package/relay-hooks/useLazyLoadQueryNode.js.flow

@@ -19,7 +19,9 @@ import type {
   OperationType,
   RenderPolicy,
 } from 'relay-runtime';
+import type {ReaderFragment} from 'relay-runtime/util/ReaderNode';
 
+const HooksImplementation = require('./HooksImplementation');
 const ProfilerContext = require('./ProfilerContext');
 const {
   getQueryCacheIdentifier,
@@ -125,7 +127,7 @@ function useLazyLoadQueryNode<TQuery: OperationType>({
   });
 
   const {fragmentNode, fragmentRef} = preparedQueryResult;
-  const {data} = useFragmentNode<$FlowFixMe>(
+  const data = useFragmentNodeImpl(
     fragmentNode,
     fragmentRef,
     componentDisplayName,
@@ -133,4 +135,18 @@ function useLazyLoadQueryNode<TQuery: OperationType>({
   return data;
 }
 
+function useFragmentNodeImpl(
+  fragment: ReaderFragment,
+  key: mixed,
+  componentDisplayName: string,
+): mixed {
+  const impl = HooksImplementation.get();
+  if (impl && impl.useFragment__internal) {
+    return impl.useFragment__internal(fragment, key, componentDisplayName);
+  } else {
+    const {data} = useFragmentNode<mixed>(fragment, key, componentDisplayName);
+    return data;
+  }
+}
+
 module.exports = useLazyLoadQueryNode;

package/relay-hooks/usePaginationFragment.js.flow

@@ -157,15 +157,12 @@ function useLoadMore<TVariables: Variables>(
 }
 
 export type ReturnType<TVariables, TData, TKey> = {
-  // NOTE: This $Call ensures that the type of the returned data is either:
+  // NOTE: This type ensures that the type of the returned data is either:
   //   - nullable if the provided ref type is nullable
   //   - non-nullable if the provided ref type is non-nullable
-  // prettier-ignore
-  data: $Call<
-    & (<TFragmentType>( { +$fragmentSpreads: TFragmentType, ... }) =>  TData)
-    & (<TFragmentType>(?{ +$fragmentSpreads: TFragmentType, ... }) => ?TData),
-    TKey,
-  >,
+  data: [+key: TKey] extends [+key: {+$fragmentSpreads: mixed, ...}]
+    ? TData
+    : ?TData,
   loadNext: LoadMoreFn<TVariables>,
   loadPrevious: LoadMoreFn<TVariables>,
   hasNext: boolean,
@@ -186,6 +183,7 @@ function usePaginationFragment<
 ): ReturnType<TVariables, TData, TKey> {
   const impl = HooksImplementation.get();
   if (impl) {
+    // $FlowExpectedError[incompatible-return] Flow cannot prove that two conditional type satisfy each other
     return impl.usePaginationFragment<TFragmentType, TVariables, TData, TKey>(
       fragmentInput,
       parentFragmentRef,

package/relay-hooks/useRefetchableFragment.js.flow

@@ -25,16 +25,13 @@ const useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');
 const {useDebugValue} = require('react');
 const {getFragment} = require('relay-runtime');
 
-type RefetchVariables<TVariables, TKey> =
-  // NOTE: This $Call ensures that the type of the returned variables is either:
+type RefetchVariables<TVariables, TKey: ?{+$fragmentSpreads: mixed, ...}> =
+  // NOTE: This type ensures that the type of the returned variables is either:
   //   - nullable if the provided ref type is nullable
   //   - non-nullable if the provided ref type is non-nullable
-  // prettier-ignore
-  $Call<
-    & (<TFragmentType>( { +$fragmentSpreads: TFragmentType, ... }) => Partial<TVariables>)
-    & (<TFragmentType>(?{ +$fragmentSpreads: TFragmentType, ... }) => TVariables),
-    TKey,
-  >;
+  [+key: TKey] extends [+key: {+$fragmentSpreads: mixed, ...}]
+    ? Partial<TVariables>
+    : TVariables;
 
 type RefetchFnBase<TVars, TOptions> = (
   vars: TVars,
@@ -46,16 +43,15 @@ export type RefetchFn<TVariables, TKey, TOptions = Options> = RefetchFnBase<
   TOptions,
 >;
 
-export type ReturnType<TVariables, TData, TKey> = [
-  // NOTE: This $Call ensures that the type of the returned data is either:
+export type ReturnType<
+  TVariables,
+  TData,
+  TKey: ?{+$fragmentSpreads: mixed, ...},
+> = [
+  // NOTE: This type ensures that the type of the returned data is either:
   //   - nullable if the provided ref type is nullable
   //   - non-nullable if the provided ref type is non-nullable
-  // prettier-ignore
-  $Call<
-    & (<TFragmentType>( { +$fragmentSpreads: TFragmentType, ... }) =>  TData)
-    & (<TFragmentType>(?{ +$fragmentSpreads: TFragmentType, ... }) => ?TData),
-    TKey,
-  >,
+  [+key: TKey] extends [+key: {+$fragmentSpreads: mixed, ...}] ? TData : ?TData,
   RefetchFn<TVariables, TKey>,
 ];
 
@@ -115,6 +111,7 @@ function useRefetchableFragment<
 ): ReturnType<TVariables, TData, TKey> {
   const impl = HooksImplementation.get();
   if (impl) {
+    // $FlowExpectedError[incompatible-return] Flow cannot prove that two conditional type satisfy each other
     return impl.useRefetchableFragment<TFragmentType, TVariables, TData, TKey>(
       fragmentInput,
       parentFragmentRef,

package/relay-hooks/useRefetchableFragmentNode.js.flow

@@ -55,16 +55,13 @@ export type RefetchFn<
 //    /nullable/.
 //  - Or, expects /a subset/ of the query variables if the provided key type is
 //    /non-null/.
-// prettier-ignore
 export type RefetchFnDynamic<
   TQuery: OperationType,
-  TKey: ?{ +$data?: mixed, ... },
+  TKey: ?{+$data?: mixed, ...},
   TOptions = Options,
-> = $Call<
-  & (( { +$data?: mixed, ... }) => RefetchFnInexact<TQuery, TOptions>)
-  & ((?{ +$data?: mixed, ... }) => RefetchFnExact<TQuery, TOptions>),
-  TKey
->;
+> = [TKey] extends [{+$data?: mixed, ...}]
+  ? RefetchFnInexact<TQuery, TOptions>
+  : RefetchFnExact<TQuery, TOptions>;
 
 export type ReturnType<
   TQuery: OperationType,
@@ -363,6 +360,7 @@ function useRefetchableFragmentNode<
   return {
     fragmentData,
     fragmentRef,
+    // $FlowFixMe[incompatible-return] RefetchFn not compatible with RefetchFnDynamic
     refetch,
     disableStoreUpdates,
     enableStoreUpdates,

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

@@ -1,20 +0,0 @@
-'use strict';
-
-var invariant = require('invariant');
-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

@@ -1,255 +0,0 @@
-'use strict';
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var SuspenseResource = require('../SuspenseResource');
-var _require = require('./RelayReactCache'),
-  getCacheForType = _require.getCacheForType,
-  getCacheSignal = _require.getCacheSignal;
-var invariant = require('invariant');
-var _require2 = require('relay-runtime'),
-  fetchQueryInternal = _require2.__internal.fetchQuery,
-  RelayFeatureFlags = _require2.RelayFeatureFlags;
-var warning = require("fbjs/lib/warning");
-var DEFAULT_FETCH_POLICY = 'store-or-network';
-var WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
-var QueryCache = /*#__PURE__*/function () {
-  function QueryCache() {
-    this._map = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();
-  }
-  var _proto = QueryCache.prototype;
-  _proto.get = function get(environment, key) {
-    var forEnv = this._map.get(environment);
-    if (!forEnv) {
-      forEnv = new Map();
-      this._map.set(environment, forEnv);
-    }
-    return forEnv.get(key);
-  };
-  _proto.set = function set(environment, key, value) {
-    var forEnv = this._map.get(environment);
-    if (!forEnv) {
-      forEnv = new Map();
-      this._map.set(environment, forEnv);
-    }
-    forEnv.set(key, value);
-  };
-  _proto["delete"] = function _delete(environment, key) {
-    var forEnv = this._map.get(environment);
-    if (!forEnv) {
-      return;
-    }
-    forEnv["delete"](key);
-    if (forEnv.size === 0) {
-      this._map["delete"](environment);
-    }
-  };
-  return QueryCache;
-}();
-function createQueryCache() {
-  return new QueryCache();
-}
-var noopOnCommit = function noopOnCommit() {
-  return function () {
-    return undefined;
-  };
-};
-var noopPromise = new Promise(function () {});
-function getQueryCacheKey(operation, fetchPolicy, renderPolicy, fetchKey) {
-  return "".concat(fetchPolicy, "-").concat(renderPolicy, "-").concat(operation.request.identifier, "-").concat(fetchKey !== null && fetchKey !== void 0 ? fetchKey : '');
-}
-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 makeInitialCacheEntry() {
-  return {
-    status: 'pending',
-    promise: noopPromise,
-    onCommit: noopOnCommit,
-    suspenseResource: null
-  };
-}
-function getQueryResultOrFetchQuery_REACT_CACHE(environment, queryOperationDescriptor, options) {
-  var _options$fetchPolicy, _options$renderPolicy;
-  var fetchPolicy = (_options$fetchPolicy = options === null || options === void 0 ? void 0 : options.fetchPolicy) !== null && _options$fetchPolicy !== void 0 ? _options$fetchPolicy : DEFAULT_FETCH_POLICY;
-  var renderPolicy = (_options$renderPolicy = options === null || options === void 0 ? void 0 : options.renderPolicy) !== null && _options$renderPolicy !== void 0 ? _options$renderPolicy : environment.UNSTABLE_getDefaultRenderPolicy();
-  var cache = getCacheForType(createQueryCache);
-  var cacheKey = getQueryCacheKey(queryOperationDescriptor, fetchPolicy, renderPolicy, options === null || options === void 0 ? void 0 : options.fetchKey);
-  var initialEntry = cache.get(environment, cacheKey);
-  function updateCache(updater) {
-    var currentEntry = cache.get(environment, cacheKey);
-    if (!currentEntry) {
-      currentEntry = makeInitialCacheEntry();
-      cache.set(environment, cacheKey, currentEntry);
-    }
-    var newStatus = updater(currentEntry);
-    cache.set(environment, cacheKey, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, currentEntry), newStatus));
-  }
-  if (RelayFeatureFlags.USE_REACT_CACHE_LEGACY_TIMEOUTS) {
-    var _entry;
-    if (initialEntry === undefined) {
-      onCacheMiss(environment, queryOperationDescriptor, fetchPolicy, renderPolicy, updateCache, options === null || options === void 0 ? void 0 : options.fetchObservable);
-      var createdEntry = cache.get(environment, cacheKey);
-      !(createdEntry !== undefined) ? process.env.NODE_ENV !== "production" ? invariant(false, 'An entry should have been created by onCacheMiss. This is a bug in Relay.') : invariant(false) : void 0;
-      _entry = createdEntry;
-    } else {
-      _entry = initialEntry;
-    }
-    if (!_entry.suspenseResource) {
-      _entry.suspenseResource = new SuspenseResource(function () {
-        var retention = environment.retain(queryOperationDescriptor);
-        return {
-          dispose: function dispose() {
-            retention.dispose();
-            cache["delete"](environment, cacheKey);
-          }
-        };
-      });
-    }
-    if (_entry.onCommit === noopOnCommit) {
-      _entry.onCommit = function () {
-        !_entry.suspenseResource ? process.env.NODE_ENV !== "production" ? invariant(false, 'SuspenseResource should have been initialized. This is a bug in Relay.') : invariant(false) : void 0;
-        var retention = _entry.suspenseResource.permanentRetain(environment);
-        return function () {
-          retention.dispose();
-        };
-      };
-    }
-    _entry.suspenseResource.temporaryRetain(environment);
-  } else {
-    if (initialEntry === undefined) {
-      onCacheMiss(environment, queryOperationDescriptor, fetchPolicy, renderPolicy, updateCache, options === null || options === void 0 ? void 0 : options.fetchObservable);
-      var retention = environment.retain(queryOperationDescriptor);
-      var dispose = function dispose() {
-        retention.dispose();
-        cache["delete"](environment, cacheKey);
-      };
-      var abortSignal = getCacheSignal();
-      abortSignal.addEventListener('abort', dispose, {
-        once: true
-      });
-    }
-  }
-  var entry = cache.get(environment, cacheKey);
-  !(entry !== undefined) ? process.env.NODE_ENV !== "production" ? invariant(false, 'An entry should have been created by onCacheMiss. This is a bug in Relay.') : invariant(false) : void 0;
-  switch (entry.status) {
-    case 'pending':
-      throw entry.promise;
-    case 'rejected':
-      throw entry.error;
-    case 'resolved':
-      return [entry.result, entry.onCommit];
-  }
-  !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'switch statement should be exhaustive') : invariant(false) : void 0;
-}
-function onCacheMiss(environment, operation, fetchPolicy, renderPolicy, updateCache, customFetchObservable) {
-  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;
-      }
-  }
-  if (shouldFetch) {
-    executeOperationAndKeepUpToDate(environment, operation, updateCache, customFetchObservable);
-    updateCache(function (existing) {
-      switch (existing.status) {
-        case 'resolved':
-          return existing;
-        case 'rejected':
-          return existing;
-        case 'pending':
-          return shouldRenderNow ? {
-            status: 'resolved',
-            result: constructQueryResult(operation)
-          } : existing;
-      }
-    });
-  } else {
-    !shouldRenderNow ? process.env.NODE_ENV !== "production" ? invariant(false, 'Should either fetch or be willing to render. This is a bug in Relay.') : invariant(false) : void 0;
-    updateCache(function (_existing) {
-      return {
-        status: 'resolved',
-        result: constructQueryResult(operation)
-      };
-    });
-  }
-}
-function executeOperationAndKeepUpToDate(environment, operation, updateCache, customFetchObservable) {
-  var resolvePromise;
-  var promise = new Promise(function (r) {
-    resolvePromise = r;
-  });
-  promise.displayName = 'Relay(' + operation.request.node.operation.name + ')';
-  var isFirstPayload = true;
-  var fetchObservable = customFetchObservable !== null && customFetchObservable !== void 0 ? customFetchObservable : fetchQueryInternal(environment, operation);
-  fetchObservable.subscribe({
-    start: function start(subscription) {},
-    error: function error(_error) {
-      if (isFirstPayload) {
-        updateCache(function (_existing) {
-          return {
-            status: 'rejected',
-            error: _error
-          };
-        });
-      } else {
-        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) {
-      updateCache(function (_existing) {
-        return {
-          status: 'resolved',
-          result: constructQueryResult(operation)
-        };
-      });
-      resolvePromise();
-      isFirstPayload = false;
-    }
-  });
-  updateCache(function (existing) {
-    return existing.status === 'pending' ? {
-      status: 'pending',
-      promise: promise
-    } : existing;
-  });
-}
-module.exports = getQueryResultOrFetchQuery_REACT_CACHE;

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

@@ -1,33 +0,0 @@
-'use strict';
-
-var _require = require('../loadQuery'),
-  useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
-var useMemoOperationDescriptor = require('../useMemoOperationDescriptor');
-var useRelayEnvironment = require('../useRelayEnvironment');
-var getQueryResultOrFetchQuery = require('./getQueryResultOrFetchQuery_REACT_CACHE');
-var useFragmentInternal = require('./useFragmentInternal_REACT_CACHE');
-var _require2 = require('react'),
-  useEffect = _require2.useEffect;
-function useLazyLoadQuery_REACT_CACHE(gqlQuery, variables, options) {
-  var _options$networkCache;
-  useTrackLoadQueryInRender();
-  var environment = useRelayEnvironment();
-  var queryOperationDescriptor = useMemoOperationDescriptor(gqlQuery, variables, (_options$networkCache = options === null || options === void 0 ? void 0 : options.networkCacheConfig) !== null && _options$networkCache !== void 0 ? _options$networkCache : {
-    force: true
-  });
-  var _getQueryResultOrFetc = getQueryResultOrFetchQuery(environment, queryOperationDescriptor, {
-      fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
-      renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy,
-      fetchKey: options === null || options === void 0 ? void 0 : options.fetchKey
-    }),
-    queryResult = _getQueryResultOrFetc[0],
-    effect = _getQueryResultOrFetc[1];
-  useEffect(effect);
-  var fragmentNode = queryResult.fragmentNode,
-    fragmentRef = queryResult.fragmentRef;
-  return useFragmentInternal(fragmentNode, fragmentRef, 'useLazyLoadQuery()', {
-    fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
-    networkCacheConfig: options === null || options === void 0 ? void 0 : options.networkCacheConfig
-  });
-}
-module.exports = useLazyLoadQuery_REACT_CACHE;

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

@@ -1,81 +0,0 @@
-'use strict';
-
-var _require = require('../loadQuery'),
-  useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
-var useMemoOperationDescriptor = require('../useMemoOperationDescriptor');
-var useRelayEnvironment = require('../useRelayEnvironment');
-var getQueryResultOrFetchQuery = require('./getQueryResultOrFetchQuery_REACT_CACHE');
-var useFragmentInternal = require('./useFragmentInternal_REACT_CACHE');
-var invariant = require('invariant');
-var _require2 = require('react'),
-  useDebugValue = _require2.useDebugValue,
-  useEffect = _require2.useEffect;
-var _require3 = require('relay-runtime'),
-  _require3$__internal = _require3.__internal,
-  fetchQueryDeduped = _require3$__internal.fetchQueryDeduped,
-  fetchQuery = _require3$__internal.fetchQuery;
-var warning = require("fbjs/lib/warning");
-function usePreloadedQuery_REACT_CACHE(gqlQuery, preloadedQuery, options) {
-  var environment = useRelayEnvironment();
-  useTrackLoadQueryInRender();
-  var fetchKey = preloadedQuery.fetchKey,
-    fetchPolicy = preloadedQuery.fetchPolicy,
-    source = preloadedQuery.source,
-    variables = preloadedQuery.variables,
-    networkCacheConfig = preloadedQuery.networkCacheConfig;
-  var operation = useMemoOperationDescriptor(gqlQuery, variables, networkCacheConfig);
-  var fetchObservable;
-  if (preloadedQuery.kind === 'PreloadedQuery_DEPRECATED') {
-    !(operation.request.node.params.name === preloadedQuery.name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'usePreloadedQuery(): Expected data to be prefetched for query `%s`, ' + 'got prefetch results for query `%s`.', operation.request.node.params.name, preloadedQuery.name) : invariant(false) : void 0;
-    fetchObservable = fetchQueryDeduped(environment, operation.request.identifier, function () {
-      if (environment === preloadedQuery.environment && source != null) {
-        return environment.executeWithSource({
-          operation: operation,
-          source: source
-        });
-      } else {
-        return environment.execute({
-          operation: operation
-        });
-      }
-    });
-  } else {
-    process.env.NODE_ENV !== "production" ? warning(preloadedQuery.isDisposed === false, 'usePreloadedQuery(): Expected preloadedQuery to not be disposed yet. ' + 'This is because disposing the query marks it for future garbage ' + 'collection, and as such query results may no longer be present in the Relay ' + 'store. In the future, this will become a hard error.') : void 0;
-    var fallbackFetchObservable = fetchQuery(environment, operation);
-    if (source != null && environment === preloadedQuery.environment) {
-      fetchObservable = source.ifEmpty(fallbackFetchObservable);
-    } else if (environment !== preloadedQuery.environment) {
-      process.env.NODE_ENV !== "production" ? warning(false, 'usePreloadedQuery(): usePreloadedQuery was passed a preloaded query ' + 'that was created with a different environment than the one that is currently ' + 'in context. In the future, this will become a hard error.') : void 0;
-      fetchObservable = fallbackFetchObservable;
-    } else {
-      fetchObservable = fallbackFetchObservable;
-    }
-  }
-  var _getQueryResultOrFetc = getQueryResultOrFetchQuery(environment, operation, {
-      fetchPolicy: fetchPolicy,
-      renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy,
-      fetchKey: fetchKey,
-      fetchObservable: fetchObservable
-    }),
-    queryResult = _getQueryResultOrFetc[0],
-    effect = _getQueryResultOrFetc[1];
-  useEffect(effect);
-  var fragmentNode = queryResult.fragmentNode,
-    fragmentRef = queryResult.fragmentRef;
-  var data = useFragmentInternal(fragmentNode, fragmentRef, 'usePreloadedQuery()', {
-    fetchPolicy: fetchPolicy,
-    networkCacheConfig: networkCacheConfig
-  });
-  if (process.env.NODE_ENV !== "production") {
-    useDebugValue({
-      query: preloadedQuery.name,
-      variables: preloadedQuery.variables,
-      data: data,
-      fetchKey: fetchKey,
-      fetchPolicy: fetchPolicy,
-      renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy
-    });
-  }
-  return data;
-}
-module.exports = usePreloadedQuery_REACT_CACHE;

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

@@ -1,40 +0,0 @@
-/**
- * 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.
- *
- * @flow strict-local
- * @format
- * @oncall relay
- */
-
-'use strict';
-
-const invariant = require('invariant');
-// $FlowFixMe[prop-missing] These exist in experimental builds but aren't in React's types yet.
-const {unstable_getCacheForType, unstable_getCacheSignal} = require('react');
-const {RelayFeatureFlags} = require('relay-runtime');
-
-function getCacheForType<T>(factory: () => T): T {
-  invariant(
-    typeof unstable_getCacheForType === 'function' &&
-      RelayFeatureFlags.USE_REACT_CACHE,
-    '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.',
-  );
-  return unstable_getCacheForType(factory);
-}
-
-function getCacheSignal(): AbortSignal {
-  invariant(
-    typeof unstable_getCacheSignal === 'function' &&
-      RelayFeatureFlags.USE_REACT_CACHE,
-    '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.',
-  );
-  return unstable_getCacheSignal();
-}
-
-module.exports = {
-  getCacheForType,
-  getCacheSignal,
-};