@apollo/client 3.8.0-alpha.10 → 3.8.0-alpha.11

package/apollo-client.cjs

@@ -63,7 +63,7 @@ function shouldInclude(_a, variables) {
         var evaledValue = false;
         if (ifArgument.value.kind === 'Variable') {
             evaledValue = variables && variables[ifArgument.value.name.value];
-            __DEV__ ? tsInvariant.invariant(evaledValue !== void 0, "Invalid variable referenced in @".concat(directive.name.value, " directive.")) : tsInvariant.invariant(evaledValue !== void 0, 41);
+            __DEV__ ? tsInvariant.invariant(evaledValue !== void 0, "Invalid variable referenced in @".concat(directive.name.value, " directive.")) : tsInvariant.invariant(evaledValue !== void 0, 42);
         }
         else {
             evaledValue = ifArgument.value.value;
@@ -71,6 +71,7 @@ function shouldInclude(_a, variables) {
         return directive.name.value === 'skip' ? !evaledValue : evaledValue;
     });
 }
+var hasAnyDirectives = function (names, root) { return hasDirectives(names, root, false); };
 function hasDirectives(names, root, all) {
     var nameSet = new Set(names);
     var uniqueCount = nameSet.size;
@@ -99,13 +100,13 @@ function getInclusionDirectives(directives) {
                 return;
             var directiveArguments = directive.arguments;
             var directiveName = directive.name.value;
-            __DEV__ ? tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, "Incorrect number of arguments for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, 42);
+            __DEV__ ? tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, "Incorrect number of arguments for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, 43);
             var ifArgument = directiveArguments[0];
-            __DEV__ ? tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', "Invalid argument for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', 43);
+            __DEV__ ? tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', "Invalid argument for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', 44);
             var ifValue = ifArgument.value;
             __DEV__ ? tsInvariant.invariant(ifValue &&
                 (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), "Argument for the @".concat(directiveName, " directive must be a variable or a boolean value.")) : tsInvariant.invariant(ifValue &&
-                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 44);
+                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 45);
             result.push({ directive: directive, ifArgument: ifArgument });
         });
     }
@@ -118,14 +119,14 @@ function getFragmentQueryDocument(document, fragmentName) {
     document.definitions.forEach(function (definition) {
         if (definition.kind === 'OperationDefinition') {
             throw __DEV__ ? new tsInvariant.InvariantError("Found a ".concat(definition.operation, " operation").concat(definition.name ? " named '".concat(definition.name.value, "'") : '', ". ") +
-                'No operations are allowed when using a fragment as a query. Only fragments are allowed.') : new tsInvariant.InvariantError(45);
+                'No operations are allowed when using a fragment as a query. Only fragments are allowed.') : new tsInvariant.InvariantError(46);
         }
         if (definition.kind === 'FragmentDefinition') {
             fragments.push(definition);
         }
     });
     if (typeof actualFragmentName === 'undefined') {
-        __DEV__ ? tsInvariant.invariant(fragments.length === 1, "Found ".concat(fragments.length, " fragments. `fragmentName` must be provided when there is not exactly 1 fragment.")) : tsInvariant.invariant(fragments.length === 1, 46);
+        __DEV__ ? tsInvariant.invariant(fragments.length === 1, "Found ".concat(fragments.length, " fragments. `fragmentName` must be provided when there is not exactly 1 fragment.")) : tsInvariant.invariant(fragments.length === 1, 47);
         actualFragmentName = fragments[0].name.value;
     }
     var query = tslib.__assign(tslib.__assign({}, document), { definitions: tslib.__spreadArray([
@@ -166,7 +167,7 @@ function getFragmentFromSelection(selection, fragmentMap) {
                 return fragmentMap(fragmentName);
             }
             var fragment = fragmentMap && fragmentMap[fragmentName];
-            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named ".concat(fragmentName)) : tsInvariant.invariant(fragment, 47);
+            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named ".concat(fragmentName)) : tsInvariant.invariant(fragment, 48);
             return fragment || null;
         }
         default:
@@ -250,7 +251,7 @@ function valueToObjectRepresentation(argObj, name, value, variables) {
     else {
         throw __DEV__ ? new tsInvariant.InvariantError("The inline argument \"".concat(name.value, "\" of kind \"").concat(value.kind, "\"") +
             'is not supported. Use variables instead of inline arguments to ' +
-            'overcome this limitation.') : new tsInvariant.InvariantError(56);
+            'overcome this limitation.') : new tsInvariant.InvariantError(57);
     }
 }
 function storeKeyNameFromField(field, variables) {
@@ -384,16 +385,16 @@ function isInlineFragment(selection) {
 }
 
 function checkDocument(doc) {
-    __DEV__ ? tsInvariant.invariant(doc && doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc && doc.kind === 'Document', 48);
+    __DEV__ ? tsInvariant.invariant(doc && doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc && doc.kind === 'Document', 49);
     var operations = doc.definitions
         .filter(function (d) { return d.kind !== 'FragmentDefinition'; })
         .map(function (definition) {
         if (definition.kind !== 'OperationDefinition') {
-            throw __DEV__ ? new tsInvariant.InvariantError("Schema type definitions not allowed in queries. Found: \"".concat(definition.kind, "\"")) : new tsInvariant.InvariantError(49);
+            throw __DEV__ ? new tsInvariant.InvariantError("Schema type definitions not allowed in queries. Found: \"".concat(definition.kind, "\"")) : new tsInvariant.InvariantError(50);
         }
         return definition;
     });
-    __DEV__ ? tsInvariant.invariant(operations.length <= 1, "Ambiguous GraphQL document: contains ".concat(operations.length, " operations")) : tsInvariant.invariant(operations.length <= 1, 50);
+    __DEV__ ? tsInvariant.invariant(operations.length <= 1, "Ambiguous GraphQL document: contains ".concat(operations.length, " operations")) : tsInvariant.invariant(operations.length <= 1, 51);
     return doc;
 }
 function getOperationDefinition(doc) {
@@ -416,14 +417,14 @@ function getFragmentDefinitions(doc) {
 }
 function getQueryDefinition(doc) {
     var queryDef = getOperationDefinition(doc);
-    __DEV__ ? tsInvariant.invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.') : tsInvariant.invariant(queryDef && queryDef.operation === 'query', 51);
+    __DEV__ ? tsInvariant.invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.') : tsInvariant.invariant(queryDef && queryDef.operation === 'query', 52);
     return queryDef;
 }
 function getFragmentDefinition(doc) {
-    __DEV__ ? tsInvariant.invariant(doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc.kind === 'Document', 52);
-    __DEV__ ? tsInvariant.invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.') : tsInvariant.invariant(doc.definitions.length <= 1, 53);
+    __DEV__ ? tsInvariant.invariant(doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc.kind === 'Document', 53);
+    __DEV__ ? tsInvariant.invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.') : tsInvariant.invariant(doc.definitions.length <= 1, 54);
     var fragmentDef = doc.definitions[0];
-    __DEV__ ? tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.') : tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 54);
+    __DEV__ ? tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.') : tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 55);
     return fragmentDef;
 }
 function getMainDefinition(queryDoc) {
@@ -446,7 +447,7 @@ function getMainDefinition(queryDoc) {
     if (fragmentDefinition) {
         return fragmentDefinition;
     }
-    throw __DEV__ ? new tsInvariant.InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.') : new tsInvariant.InvariantError(55);
+    throw __DEV__ ? new tsInvariant.InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.') : new tsInvariant.InvariantError(56);
 }
 function getDefaultValues(definition) {
     var defaultValues = Object.create(null);
@@ -1167,7 +1168,7 @@ function stringifyForDisplay(value) {
 
 function mergeOptions(defaults, options) {
     return compact(defaults, options, options.variables && {
-        variables: tslib.__assign(tslib.__assign({}, (defaults && defaults.variables)), options.variables),
+        variables: compact(tslib.__assign(tslib.__assign({}, (defaults && defaults.variables)), options.variables)),
     });
 }
 
@@ -1395,7 +1396,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.8.0-alpha.10';
+var version = '3.8.0-alpha.11';
 
 function asyncIterator(source) {
     var _a;
@@ -1968,6 +1969,7 @@ var HttpLink = (function (_super) {
 
 var ApolloCache = (function () {
     function ApolloCache() {
+        this.assumeImmutableResults = false;
         this.getFragmentDoc = optimism.wrap(getFragmentQueryDocument);
     }
     ApolloCache.prototype.batch = function (options) {
@@ -3973,6 +3975,7 @@ var InMemoryCache = (function (_super) {
         var _this = _super.call(this) || this;
         _this.watches = new Set();
         _this.typenameDocumentCache = new Map();
+        _this.assumeImmutableResults = true;
         _this.makeVar = makeVar;
         _this.txCount = 0;
         _this.config = normalizeConfig(config);
@@ -4317,6 +4320,9 @@ exports.NetworkStatus = void 0;
 function isNetworkRequestInFlight(networkStatus) {
     return networkStatus ? networkStatus < 7 : false;
 }
+function isNetworkRequestSettled(networkStatus) {
+    return networkStatus === 7 || networkStatus === 8;
+}
 
 var assign = Object.assign, hasOwnProperty$2 = Object.hasOwnProperty;
 var ObservableQuery = (function (_super) {
@@ -4324,14 +4330,13 @@ var ObservableQuery = (function (_super) {
     function ObservableQuery(_a) {
         var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;
         var _this = _super.call(this, function (observer) {
-            var _a = options.fetchOnFirstSubscribe, fetchOnFirstSubscribe = _a === void 0 ? true : _a;
             try {
                 var subObserver = observer._subscription._observer;
                 if (subObserver && !subObserver.error) {
                     subObserver.error = defaultSubscriptionObserverErrorCallback;
                 }
             }
-            catch (_b) { }
+            catch (_a) { }
             var first = !_this.observers.size;
             _this.observers.add(observer);
             var last = _this.last;
@@ -4341,7 +4346,7 @@ var ObservableQuery = (function (_super) {
             else if (last && last.result) {
                 observer.next && observer.next(last.result);
             }
-            if (first && fetchOnFirstSubscribe) {
+            if (first) {
                 _this.reobserve().catch(function () { });
             }
             return function () {
@@ -4704,7 +4709,7 @@ var ObservableQuery = (function (_super) {
         }
         return this.last;
     };
-    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {
+    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
         var _this = this;
         this.isTornDown = false;
         var useDisposableConcast = newNetworkStatus === exports.NetworkStatus.refetch ||
@@ -4747,10 +4752,7 @@ var ObservableQuery = (function (_super) {
             this.observer = observer;
         }
         concast.addObserver(observer);
-        return concast;
-    };
-    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
-        return this.reobserveAsConcast(newOptions, newNetworkStatus).promise;
+        return concast.promise;
     };
     ObservableQuery.prototype.observe = function () {
         this.reportResult(this.getCurrentResult(false), this.variables);
@@ -5412,7 +5414,7 @@ function shouldWriteResult(result, errorPolicy) {
 var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
 var QueryManager = (function () {
     function QueryManager(_a) {
-        var cache = _a.cache, link = _a.link, defaultOptions = _a.defaultOptions, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, onBroadcast = _a.onBroadcast, _c = _a.ssrMode, ssrMode = _c === void 0 ? false : _c, _d = _a.clientAwareness, clientAwareness = _d === void 0 ? {} : _d, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;
+        var cache = _a.cache, link = _a.link, defaultOptions = _a.defaultOptions, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, onBroadcast = _a.onBroadcast, _c = _a.ssrMode, ssrMode = _c === void 0 ? false : _c, _d = _a.clientAwareness, clientAwareness = _d === void 0 ? {} : _d, localState = _a.localState, _e = _a.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? !!cache.assumeImmutableResults : _e;
         this.clientAwareness = {};
         this.queries = new Map();
         this.fetchCancelFns = new Map();
@@ -5428,7 +5430,7 @@ var QueryManager = (function () {
         this.clientAwareness = clientAwareness;
         this.localState = localState || new LocalState({ cache: cache });
         this.ssrMode = ssrMode;
-        this.assumeImmutableResults = !!assumeImmutableResults;
+        this.assumeImmutableResults = assumeImmutableResults;
         if ((this.onBroadcast = onBroadcast)) {
             this.mutationStore = Object.create(null);
         }
@@ -6291,20 +6293,20 @@ var ApolloClient = (function () {
         var _this = this;
         this.resetStoreCallbacks = [];
         this.clearStoreCallbacks = [];
+        if (!options.cache) {
+            throw __DEV__ ? new tsInvariant.InvariantError("To initialize Apollo Client, you must specify a 'cache' property " +
+                "in the options object. \n" +
+                "For more information, please visit: https://go.apollo.dev/c/docs") : new tsInvariant.InvariantError(9);
+        }
         var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, _c = options.connectToDevTools, connectToDevTools = _c === void 0 ? typeof window === 'object' &&
             !window.__APOLLO_CLIENT__ &&
-            __DEV__ : _c, _d = options.queryDeduplication, queryDeduplication = _d === void 0 ? true : _d, defaultOptions = options.defaultOptions, _e = options.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? false : _e, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;
+            __DEV__ : _c, _d = options.queryDeduplication, queryDeduplication = _d === void 0 ? true : _d, defaultOptions = options.defaultOptions, _e = options.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? cache.assumeImmutableResults : _e, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;
         var link = options.link;
         if (!link) {
             link = uri
                 ? new HttpLink({ uri: uri, credentials: credentials, headers: headers })
                 : ApolloLink.empty();
         }
-        if (!cache) {
-            throw __DEV__ ? new tsInvariant.InvariantError("To initialize Apollo Client, you must specify a 'cache' property " +
-                "in the options object. \n" +
-                "For more information, please visit: https://go.apollo.dev/c/docs") : new tsInvariant.InvariantError(9);
-        }
         this.link = link;
         this.cache = cache;
         this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;
@@ -6542,7 +6544,7 @@ var ApolloConsumer = function (props) {
     var ApolloContext = getApolloContext();
     return (React__namespace.createElement(ApolloContext.Consumer, null, function (context) {
         __DEV__ ? tsInvariant.invariant(context && context.client, 'Could not find "client" in the context of ApolloConsumer. ' +
-            'Wrap the root component in an <ApolloProvider>.') : tsInvariant.invariant(context && context.client, 28);
+            'Wrap the root component in an <ApolloProvider>.') : tsInvariant.invariant(context && context.client, 29);
         return props.children(context.client);
     }));
 };
@@ -6559,7 +6561,7 @@ var ApolloProvider = function (_a) {
             context = Object.assign({}, context, { suspenseCache: suspenseCache });
         }
         __DEV__ ? tsInvariant.invariant(context.client, 'ApolloProvider was not passed a client instance. Make ' +
-            'sure you pass in your client via the "client" prop.') : tsInvariant.invariant(context.client, 29);
+            'sure you pass in your client via the "client" prop.') : tsInvariant.invariant(context.client, 30);
         return (React__namespace.createElement(ApolloContext.Provider, { value: context }, children));
     }));
 };
@@ -6569,7 +6571,7 @@ function useApolloClient(override) {
     var client = override || context.client;
     __DEV__ ? tsInvariant.invariant(!!client, 'Could not find "client" in the context or passed in as an option. ' +
         'Wrap the root component in an <ApolloProvider>, or pass an ApolloClient ' +
-        'instance in via options.') : tsInvariant.invariant(!!client, 32);
+        'instance in via options.') : tsInvariant.invariant(!!client, 33);
     return client;
 }
 
@@ -6647,7 +6649,7 @@ function parser(document) {
     var variables, type, name;
     __DEV__ ? tsInvariant.invariant(!!document && !!document.kind, "Argument of ".concat(document, " passed to parser was not a valid GraphQL ") +
         "DocumentNode. You may need to use 'graphql-tag' or another method " +
-        "to convert your operation into a document") : tsInvariant.invariant(!!document && !!document.kind, 35);
+        "to convert your operation into a document") : tsInvariant.invariant(!!document && !!document.kind, 36);
     var fragments = [];
     var queries = [];
     var mutations = [];
@@ -6675,11 +6677,11 @@ function parser(document) {
     __DEV__ ? tsInvariant.invariant(!fragments.length ||
         (queries.length || mutations.length || subscriptions.length), "Passing only a fragment to 'graphql' is not yet supported. " +
         "You must include a query, subscription or mutation as well") : tsInvariant.invariant(!fragments.length ||
-        (queries.length || mutations.length || subscriptions.length), 36);
+        (queries.length || mutations.length || subscriptions.length), 37);
     __DEV__ ? tsInvariant.invariant(queries.length + mutations.length + subscriptions.length <= 1, "react-apollo only supports a query, subscription, or a mutation per HOC. " +
         "".concat(document, " had ").concat(queries.length, " queries, ").concat(subscriptions.length, " ") +
         "subscriptions and ".concat(mutations.length, " mutations. ") +
-        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(queries.length + mutations.length + subscriptions.length <= 1, 37);
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(queries.length + mutations.length + subscriptions.length <= 1, 38);
     type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;
     if (!queries.length && !mutations.length)
         type = exports.DocumentType.Subscription;
@@ -6690,7 +6692,7 @@ function parser(document) {
             : subscriptions;
     __DEV__ ? tsInvariant.invariant(definitions.length === 1, "react-apollo only supports one definition per HOC. ".concat(document, " had ") +
         "".concat(definitions.length, " definitions. ") +
-        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(definitions.length === 1, 38);
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(definitions.length === 1, 39);
     var definition = definitions[0];
     variables = definition.variableDefinitions || [];
     if (definition.name && definition.name.kind === 'Name') {
@@ -6708,7 +6710,7 @@ function verifyDocumentType(document, type) {
     var requiredOperationName = operationName(type);
     var usedOperationName = operationName(operation.type);
     __DEV__ ? tsInvariant.invariant(operation.type === type, "Running a ".concat(requiredOperationName, " requires a graphql ") +
-        "".concat(requiredOperationName, ", but a ").concat(usedOperationName, " was used instead.")) : tsInvariant.invariant(operation.type === type, 39);
+        "".concat(requiredOperationName, ", but a ").concat(usedOperationName, " was used instead.")) : tsInvariant.invariant(operation.type === type, 40);
 }
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -7353,124 +7355,123 @@ function useDeepMemo(memoFn, deps) {
     return ref.current.value;
 }
 
-var useIsomorphicLayoutEffect = canUseLayoutEffect
-    ? React.useLayoutEffect
-    : React.useEffect;
+function useStrictModeSafeCleanupEffect(cleanup) {
+    var timeout;
+    React.useEffect(function () {
+        clearTimeout(timeout);
+        return function () {
+            timeout = setTimeout(cleanup);
+        };
+    }, []);
+}
+
+function isStatefulPromise(promise) {
+    return 'status' in promise;
+}
+function wrapPromiseWithState(promise) {
+    if (isStatefulPromise(promise)) {
+        return promise;
+    }
+    var pendingPromise = promise;
+    pendingPromise.status = 'pending';
+    pendingPromise.then(function (value) {
+        if (pendingPromise.status === 'pending') {
+            var fulfilledPromise = pendingPromise;
+            fulfilledPromise.status = 'fulfilled';
+            fulfilledPromise.value = value;
+        }
+    }, function (reason) {
+        if (pendingPromise.status === 'pending') {
+            var rejectedPromise = pendingPromise;
+            rejectedPromise.status = 'rejected';
+            rejectedPromise.reason = reason;
+        }
+    });
+    return promise;
+}
+
+function __use(promise) {
+    var statefulPromise = wrapPromiseWithState(promise);
+    switch (statefulPromise.status) {
+        case 'pending':
+            throw statefulPromise;
+        case 'rejected':
+            throw statefulPromise.reason;
+        case 'fulfilled':
+            return statefulPromise.value;
+    }
+}
 
 function useSuspenseCache(override) {
     var context = React.useContext(getApolloContext());
     var suspenseCache = override || context.suspenseCache;
     __DEV__ ? tsInvariant.invariant(suspenseCache, 'Could not find a "suspenseCache" in the context or passed in as an option. ' +
         'Wrap the root component in an <ApolloProvider> and provide a suspenseCache, ' +
-        'or pass a SuspenseCache instance in via options.') : tsInvariant.invariant(suspenseCache, 33);
+        'or pass a SuspenseCache instance in via options.') : tsInvariant.invariant(suspenseCache, 34);
     return suspenseCache;
 }
 
-var SUPPORTED_FETCH_POLICIES = [
-    'cache-first',
-    'network-only',
-    'no-cache',
-    'cache-and-network',
-];
-var DEFAULT_FETCH_POLICY = 'cache-first';
-var DEFAULT_SUSPENSE_POLICY = 'always';
-var DEFAULT_ERROR_POLICY = 'none';
 function useSuspenseQuery_experimental(query, options) {
     if (options === void 0) { options = Object.create(null); }
-    var suspenseCache = useSuspenseCache(options.suspenseCache);
+    var didPreviouslySuspend = React.useRef(false);
     var client = useApolloClient(options.client);
-    var watchQueryOptions = useWatchQueryOptions({ query: query, options: options, client: client });
-    var previousWatchQueryOptionsRef = React.useRef(watchQueryOptions);
-    var deferred = useIsDeferred(query);
-    var fetchPolicy = watchQueryOptions.fetchPolicy, errorPolicy = watchQueryOptions.errorPolicy, returnPartialData = watchQueryOptions.returnPartialData, variables = watchQueryOptions.variables;
-    var cacheEntry = suspenseCache.lookup(query, variables);
-    var observable = React.useState(function () {
-        return (cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.observable) || client.watchQuery(watchQueryOptions);
-    })[0];
-    var result = useObservableQueryResult(observable);
-    var hasFullResult = result.data && !result.partial;
-    var hasPartialResult = result.data && result.partial;
-    var usePartialResult = returnPartialData && hasPartialResult;
-    var allowsThrownErrors = errorPolicy === 'none' && (!deferred || !hasPartialResult);
-    if (result.error &&
-        (result.error.networkError || allowsThrownErrors)) {
-        throw result.error;
-    }
-    if (result.loading) {
-        if (!cacheEntry) {
-            cacheEntry = suspenseCache.add(query, variables, {
-                promise: maybeWrapConcastWithCustomPromise(observable.reobserveAsConcast(watchQueryOptions), { deferred: deferred }),
-                observable: observable,
-            });
-        }
-        var hasUsableResult = usePartialResult ||
-            (fetchPolicy === 'cache-and-network' && hasFullResult);
-        if (!hasUsableResult && !cacheEntry.fulfilled) {
-            throw cacheEntry.promise;
-        }
-    }
-    React.useEffect(function () {
-        var variables = watchQueryOptions.variables, query = watchQueryOptions.query;
-        var previousOpts = previousWatchQueryOptionsRef.current;
-        if (variables !== previousOpts.variables || query !== previousOpts.query) {
-            suspenseCache.remove(previousOpts.query, previousOpts.variables);
-            suspenseCache.add(query, variables, {
-                promise: observable.reobserve({ query: query, variables: variables }),
-                observable: observable,
-            });
-            previousWatchQueryOptionsRef.current = watchQueryOptions;
-        }
-    }, [watchQueryOptions]);
-    React.useEffect(function () {
-        return function () {
-            suspenseCache.remove(query, variables);
-        };
-    }, []);
-    var fetchMore = React.useCallback(function (options) {
-        var promise = observable.fetchMore(options);
-        suspenseCache.add(query, watchQueryOptions.variables, {
-            promise: promise,
-            observable: observable,
-        });
-        return promise;
-    }, [observable]);
-    var refetch = React.useCallback(function (variables) {
-        var promise = observable.refetch(variables);
-        suspenseCache.add(query, watchQueryOptions.variables, {
-            promise: promise,
-            observable: observable,
-        });
-        return promise;
-    }, [observable]);
-    var subscribeToMore = React.useCallback(function (options) { return observable.subscribeToMore(options); }, [observable]);
+    var suspenseCache = useSuspenseCache(options.suspenseCache);
+    var watchQueryOptions = useWatchQueryOptions({ query: query, options: options });
+    var _a = watchQueryOptions.returnPartialData, returnPartialData = _a === void 0 ? false : _a, variables = watchQueryOptions.variables;
+    var _b = options.suspensePolicy, suspensePolicy = _b === void 0 ? 'always' : _b;
+    var shouldSuspend = suspensePolicy === 'always' || !didPreviouslySuspend.current;
+    var subscription = suspenseCache.getSubscription(client, query, variables, function () { return client.watchQuery(watchQueryOptions); });
+    var dispose = useTrackedSubscriptions(subscription);
+    useStrictModeSafeCleanupEffect(dispose);
+    var result = useSyncExternalStore(subscription.listen, function () { return subscription.result; }, function () { return subscription.result; });
+    var previousVariables = React.useRef(variables);
+    var previousData = React.useRef(result.data);
+    if (!equality.equal(variables, previousVariables.current)) {
+        if (result.networkStatus !== exports.NetworkStatus.ready) {
+            result = tslib.__assign(tslib.__assign({}, result), { data: previousData.current, networkStatus: exports.NetworkStatus.setVariables });
+        }
+        previousVariables.current = variables;
+        previousData.current = result.data;
+    }
+    if (result.networkStatus === exports.NetworkStatus.error ||
+        (shouldSuspend &&
+            !shouldUseCachedResult(subscription.result, {
+                returnPartialData: returnPartialData,
+                fetchPolicy: options.fetchPolicy,
+            }))) {
+        __use(subscription.promise);
+    }
+    didPreviouslySuspend.current = true;
+    var fetchMore = React.useCallback(function (options) { return subscription.fetchMore(options); }, [subscription]);
+    var refetch = React.useCallback(function (variables) { return subscription.refetch(variables); }, [subscription]);
+    var subscribeToMore = React.useCallback(function (options) { return subscription.observable.subscribeToMore(options); }, [subscription]);
     return React.useMemo(function () {
         return {
             client: client,
             data: result.data,
-            error: errorPolicy === 'ignore' ? void 0 : toApolloError(result),
+            error: toApolloError(result),
             networkStatus: result.networkStatus,
             fetchMore: fetchMore,
             refetch: refetch,
             subscribeToMore: subscribeToMore,
         };
-    }, [
-        client,
-        fetchMore,
-        refetch,
-        result,
-        observable,
-        errorPolicy,
-        subscribeToMore,
-    ]);
+    }, [client, fetchMore, refetch, result, subscribeToMore]);
 }
 function validateOptions(options) {
-    var query = options.query, _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? DEFAULT_FETCH_POLICY : _a, returnPartialData = options.returnPartialData;
+    var query = options.query, fetchPolicy = options.fetchPolicy, returnPartialData = options.returnPartialData;
     verifyDocumentType(query, exports.DocumentType.Query);
     validateFetchPolicy(fetchPolicy);
     validatePartialDataReturn(fetchPolicy, returnPartialData);
 }
 function validateFetchPolicy(fetchPolicy) {
-    __DEV__ ? tsInvariant.invariant(SUPPORTED_FETCH_POLICIES.includes(fetchPolicy), "The fetch policy `".concat(fetchPolicy, "` is not supported with suspense.")) : tsInvariant.invariant(SUPPORTED_FETCH_POLICIES.includes(fetchPolicy), 34);
+    if (fetchPolicy === void 0) { fetchPolicy = 'cache-first'; }
+    var supportedFetchPolicies = [
+        'cache-first',
+        'network-only',
+        'no-cache',
+        'cache-and-network',
+    ];
+    __DEV__ ? tsInvariant.invariant(supportedFetchPolicies.includes(fetchPolicy), "The fetch policy `".concat(fetchPolicy, "` is not supported with suspense.")) : tsInvariant.invariant(supportedFetchPolicies.includes(fetchPolicy), 35);
 }
 function validatePartialDataReturn(fetchPolicy, returnPartialData) {
     if (fetchPolicy === 'no-cache' && returnPartialData) {
@@ -7482,125 +7483,137 @@ function toApolloError(result) {
         ? new ApolloError({ graphQLErrors: result.errors })
         : result.error;
 }
-function maybeWrapConcastWithCustomPromise(concast, _a) {
-    var deferred = _a.deferred;
-    if (deferred) {
-        return new Promise(function (resolve, reject) {
-            var subscription = concast.subscribe({
-                next: function (value) {
-                    resolve(value);
-                    subscription.unsubscribe();
-                },
-                error: reject,
-            });
-        });
-    }
-    return concast.promise;
+function useTrackedSubscriptions(subscription) {
+    var trackedSubscriptions = React.useRef(new Set());
+    trackedSubscriptions.current.add(subscription);
+    return function dispose() {
+        trackedSubscriptions.current.forEach(function (sub) { return sub.dispose(); });
+    };
 }
 function useWatchQueryOptions(_a) {
-    var query = _a.query, options = _a.options, client = _a.client;
-    var defaultOptions = client.defaultOptions.watchQuery;
-    var watchQueryOptions = useDeepMemo(function () {
-        var errorPolicy = options.errorPolicy, fetchPolicy = options.fetchPolicy, _a = options.suspensePolicy, suspensePolicy = _a === void 0 ? DEFAULT_SUSPENSE_POLICY : _a, variables = options.variables, watchQueryOptions = tslib.__rest(options, ["errorPolicy", "fetchPolicy", "suspensePolicy", "variables"]);
-        return tslib.__assign(tslib.__assign({}, watchQueryOptions), { query: query, errorPolicy: errorPolicy || (defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.errorPolicy) || DEFAULT_ERROR_POLICY, fetchPolicy: fetchPolicy || (defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.fetchPolicy) || DEFAULT_FETCH_POLICY, notifyOnNetworkStatusChange: suspensePolicy === 'always', fetchOnFirstSubscribe: false, variables: compact(tslib.__assign(tslib.__assign({}, defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.variables), variables)) });
-    }, [options, query, defaultOptions]);
+    var query = _a.query, options = _a.options;
+    var watchQueryOptions = useDeepMemo(function () { return (tslib.__assign(tslib.__assign({}, options), { query: query, notifyOnNetworkStatusChange: true, nextFetchPolicy: void 0 })); }, [options, query]);
     if (__DEV__) {
         validateOptions(watchQueryOptions);
     }
     return watchQueryOptions;
 }
-function useIsDeferred(query) {
-    return React.useMemo(function () { return hasDirectives(['defer'], query); }, [query]);
-}
-function useObservableQueryResult(observable) {
-    var resultRef = React.useRef();
-    var isMountedRef = React.useRef(false);
-    var subscribeTimeoutRef = React.useRef();
-    if (!resultRef.current) {
-        resultRef.current = observable.getCurrentResult();
+function shouldUseCachedResult(result, _a) {
+    var returnPartialData = _a.returnPartialData, fetchPolicy = _a.fetchPolicy;
+    if (result.networkStatus === exports.NetworkStatus.refetch ||
+        result.networkStatus === exports.NetworkStatus.fetchMore ||
+        result.networkStatus === exports.NetworkStatus.error) {
+        return false;
     }
-    useIsomorphicLayoutEffect(function () {
-        isMountedRef.current = true;
-        return function () {
-            isMountedRef.current = false;
-        };
-    }, []);
-    return useSyncExternalStore(React.useCallback(function (forceUpdate) {
-        clearTimeout(subscribeTimeoutRef.current);
-        function handleUpdate() {
-            var previousResult = resultRef.current;
-            var result = observable.getCurrentResult();
-            if (previousResult.loading === result.loading &&
-                previousResult.networkStatus === result.networkStatus &&
-                equality.equal(previousResult.data, result.data)) {
-                return;
-            }
-            resultRef.current = result;
-            if (isMountedRef.current) {
-                forceUpdate();
-            }
+    switch (fetchPolicy) {
+        case void 0:
+        case 'cache-first':
+        case 'cache-and-network': {
+            return Boolean(result.data && (!result.partial || returnPartialData));
         }
-        var subscription;
-        subscribeTimeoutRef.current = setTimeout(function () {
-            subscription = observable.subscribe({
-                next: handleUpdate,
-                error: handleUpdate,
-            });
-            var result = resultRef.current;
-            if (result.networkStatus !== observable['queryInfo'].networkStatus &&
-                result.networkStatus === exports.NetworkStatus.ready) {
-                observable['queryInfo'].markReady();
-            }
-        });
-        return function () {
-            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
-        };
-    }, [observable]), function () { return resultRef.current; }, function () { return resultRef.current; });
+        default:
+            return false;
+    }
 }
 
-var SuspenseCache = (function () {
-    function SuspenseCache() {
-        this.queries = new Map();
-    }
-    SuspenseCache.prototype.add = function (query, variables, _a) {
-        var promise = _a.promise, observable = _a.observable;
-        var variablesKey = this.getVariablesKey(variables);
-        var map = this.queries.get(query) || new Map();
-        var entry = {
-            observable: observable,
-            fulfilled: false,
-            promise: promise
-                .catch(function () {
-            })
-                .finally(function () {
-                entry.fulfilled = true;
-            }),
+function wrapWithCustomPromise(concast) {
+    return new Promise(function (resolve, reject) {
+        var subscription = concast.subscribe({
+            next: function (value) {
+                resolve(value);
+                subscription.unsubscribe();
+            },
+            error: reject,
+        });
+    });
+}
+var isMultipartQuery = optimism.wrap(function (query) {
+    return hasAnyDirectives(['defer', 'stream'], query);
+});
+var QuerySubscription = (function () {
+    function QuerySubscription(observable, options) {
+        if (options === void 0) { options = Object.create(null); }
+        var _a;
+        this.listeners = new Set();
+        this.listen = this.listen.bind(this);
+        this.handleNext = this.handleNext.bind(this);
+        this.handleError = this.handleError.bind(this);
+        this.dispose = this.dispose.bind(this);
+        this.observable = observable;
+        this.result = observable.getCurrentResult();
+        if (options.onDispose) {
+            this.onDispose = options.onDispose;
+        }
+        this.subscription = observable.subscribe({
+            next: this.handleNext,
+            error: this.handleError,
+        });
+        __DEV__ ? tsInvariant.invariant(observable['concast'], 'Unexpected error: A concast was not found on the observable.') : tsInvariant.invariant(observable['concast'], 28);
+        var concast = observable['concast'];
+        this.promise = isMultipartQuery(observable.query)
+            ? wrapWithCustomPromise(concast)
+            : concast.promise;
+        this.autoDisposeTimeoutId = setTimeout(this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);
+    }
+    QuerySubscription.prototype.listen = function (listener) {
+        var _this = this;
+        clearTimeout(this.autoDisposeTimeoutId);
+        this.listeners.add(listener);
+        return function () {
+            _this.listeners.delete(listener);
         };
-        map.set(variablesKey, entry);
-        this.queries.set(query, map);
-        return entry;
     };
-    SuspenseCache.prototype.lookup = function (query, variables) {
-        var _a;
-        return (_a = this.queries
-            .get(query)) === null || _a === void 0 ? void 0 : _a.get(this.getVariablesKey(variables));
+    QuerySubscription.prototype.refetch = function (variables) {
+        this.promise = this.observable.refetch(variables);
+        return this.promise;
     };
-    SuspenseCache.prototype.remove = function (query, variables) {
-        var map = this.queries.get(query);
-        if (!map) {
-            return;
-        }
-        var key = this.getVariablesKey(variables);
-        var entry = map.get(key);
-        if (entry && !entry.observable.hasObservers()) {
-            map.delete(key);
-        }
-        if (map.size === 0) {
-            this.queries.delete(query);
+    QuerySubscription.prototype.fetchMore = function (options) {
+        this.promise = this.observable.fetchMore(options);
+        return this.promise;
+    };
+    QuerySubscription.prototype.dispose = function () {
+        this.subscription.unsubscribe();
+        this.onDispose();
+    };
+    QuerySubscription.prototype.onDispose = function () {
+    };
+    QuerySubscription.prototype.handleNext = function (result) {
+        if (isNetworkRequestSettled(result.networkStatus) &&
+            this.result.data &&
+            result.data === void 0) {
+            result.data = this.result.data;
         }
+        this.result = result;
+        this.deliver(result);
+    };
+    QuerySubscription.prototype.handleError = function (error) {
+        var result = tslib.__assign(tslib.__assign({}, this.result), { error: error, networkStatus: exports.NetworkStatus.error });
+        this.result = result;
+        this.deliver(result);
     };
-    SuspenseCache.prototype.getVariablesKey = function (variables) {
-        return canonicalStringify(variables || Object.create(null));
+    QuerySubscription.prototype.deliver = function (result) {
+        this.listeners.forEach(function (listener) { return listener(result); });
+    };
+    return QuerySubscription;
+}());
+
+var SuspenseCache = (function () {
+    function SuspenseCache(options) {
+        if (options === void 0) { options = Object.create(null); }
+        this.cacheKeys = new trie.Trie(canUseWeakMap, function (cacheKey) { return cacheKey; });
+        this.subscriptions = new Map();
+        this.options = options;
+    }
+    SuspenseCache.prototype.getSubscription = function (client, query, variables, createObservable) {
+        var _this = this;
+        var cacheKey = this.cacheKeys.lookup(client, query, canonicalStringify(variables));
+        if (!this.subscriptions.has(cacheKey)) {
+            this.subscriptions.set(cacheKey, new QuerySubscription(createObservable(), {
+                autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs,
+                onDispose: function () { return _this.subscriptions.delete(cacheKey); },
+            }));
+        }
+        return this.subscriptions.get(cacheKey);
     };
     return SuspenseCache;
 }());