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

package/apollo-client.cjs

@@ -4,10 +4,11 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 var tsInvariant = require('ts-invariant');
+var process$1 = require('ts-invariant/process');
+var graphql = require('graphql');
 var equality = require('@wry/equality');
 var zenObservableTs = require('zen-observable-ts');
 require('symbol-observable');
-var graphql = require('graphql');
 var optimism = require('optimism');
 var context = require('@wry/context');
 var trie = require('@wry/trie');
@@ -35,6 +36,23 @@ function maybe(thunk) {
     catch (_a) { }
 }
 
+var global$1 = (maybe(function () { return globalThis; }) ||
+    maybe(function () { return window; }) ||
+    maybe(function () { return self; }) ||
+    maybe(function () { return global; }) ||
+    maybe(function () { return maybe.constructor("return this")(); }));
+
+var DEV = ("__DEV__" in global$1
+    ? Boolean(global$1.__DEV__)
+    : maybe(function () { return process.env.NODE_ENV; }) !== "production");
+
+function removeTemporaryGlobals() {
+    return typeof graphql.Source === "function" ? process$1.remove() : process$1.remove();
+}
+
+var __DEV__ = DEV;
+removeTemporaryGlobals();
+
 function shouldInclude(_a, variables) {
     var directives = _a.directives;
     if (!directives || !directives.length) {
@@ -380,17 +398,21 @@ function checkDocument(doc) {
 }
 function getOperationDefinition(doc) {
     checkDocument(doc);
-    return doc.definitions.filter(function (definition) { return definition.kind === 'OperationDefinition'; })[0];
+    return doc.definitions.filter(function (definition) {
+        return definition.kind === 'OperationDefinition';
+    })[0];
 }
 function getOperationName(doc) {
     return (doc.definitions
         .filter(function (definition) {
-        return definition.kind === 'OperationDefinition' && definition.name;
+        return definition.kind === 'OperationDefinition' && !!definition.name;
     })
         .map(function (x) { return x.name.value; })[0] || null);
 }
 function getFragmentDefinitions(doc) {
-    return doc.definitions.filter(function (definition) { return definition.kind === 'FragmentDefinition'; });
+    return doc.definitions.filter(function (definition) {
+        return definition.kind === 'FragmentDefinition';
+    });
 }
 function getQueryDefinition(doc) {
     var queryDef = getOperationDefinition(doc);
@@ -439,26 +461,20 @@ function getDefaultValues(definition) {
     return defaultValues;
 }
 
-function filterInPlace(array, test, context) {
-    var target = 0;
-    array.forEach(function (elem, i) {
-        if (test.call(this, elem, i, array)) {
-            array[target++] = elem;
-        }
-    }, context);
-    array.length = target;
-    return array;
+var isArray = Array.isArray;
+function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
 }
 
 var TYPENAME_FIELD = {
-    kind: 'Field',
+    kind: graphql.Kind.FIELD,
     name: {
-        kind: 'Name',
+        kind: graphql.Kind.NAME,
         value: '__typename',
     },
 };
 function isEmpty(op, fragmentMap) {
-    return !op || op.selectionSet.selections.every(function (selection) { return selection.kind === 'FragmentSpread' &&
+    return !op || op.selectionSet.selections.every(function (selection) { return selection.kind === graphql.Kind.FRAGMENT_SPREAD &&
         isEmpty(fragmentMap[selection.name.value], fragmentMap); });
 }
 function nullIfDocIsEmpty(doc) {
@@ -467,84 +483,190 @@ function nullIfDocIsEmpty(doc) {
         : doc;
 }
 function getDirectiveMatcher(directives) {
-    return function directiveMatcher(directive) {
-        return directives.some(function (dir) {
-            return (dir.name && dir.name === directive.name.value) ||
-                (dir.test && dir.test(directive));
-        });
+    var nameSet = new Set();
+    var tests = [];
+    directives.forEach(function (directive) {
+        if (directive.name) {
+            nameSet.add(directive.name);
+        }
+        else if (directive.test) {
+            tests.push(directive.test);
+        }
+    });
+    return function (directive) { return (nameSet.has(directive.name.value) ||
+        tests.some(function (test) { return test(directive); })); };
+}
+function makeInUseGetterFunction(defaultKey) {
+    var map = new Map();
+    return function inUseGetterFunction(key) {
+        if (key === void 0) { key = defaultKey; }
+        var inUse = map.get(key);
+        if (!inUse) {
+            map.set(key, inUse = {
+                variables: new Set,
+                fragmentSpreads: new Set,
+            });
+        }
+        return inUse;
     };
 }
 function removeDirectivesFromDocument(directives, doc) {
-    var variablesInUse = Object.create(null);
-    var variablesToRemove = [];
-    var fragmentSpreadsInUse = Object.create(null);
-    var fragmentSpreadsToRemove = [];
-    var modifiedDoc = nullIfDocIsEmpty(graphql.visit(doc, {
+    var getInUseByOperationName = makeInUseGetterFunction("");
+    var getInUseByFragmentName = makeInUseGetterFunction("");
+    var getInUse = function (ancestors) {
+        for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {
+            if (isArray(ancestor))
+                continue;
+            if (ancestor.kind === graphql.Kind.OPERATION_DEFINITION) {
+                return getInUseByOperationName(ancestor.name && ancestor.name.value);
+            }
+            if (ancestor.kind === graphql.Kind.FRAGMENT_DEFINITION) {
+                return getInUseByFragmentName(ancestor.name.value);
+            }
+        }
+        __DEV__ && tsInvariant.invariant.error("Could not find operation or fragment");
+        return null;
+    };
+    var operationCount = 0;
+    for (var i = doc.definitions.length - 1; i >= 0; --i) {
+        if (doc.definitions[i].kind === graphql.Kind.OPERATION_DEFINITION) {
+            ++operationCount;
+        }
+    }
+    var directiveMatcher = getDirectiveMatcher(directives);
+    var hasRemoveDirective = directives.some(function (directive) { return directive.remove; });
+    var shouldRemoveField = function (nodeDirectives) { return (hasRemoveDirective &&
+        nodeDirectives &&
+        nodeDirectives.some(directiveMatcher)); };
+    var originalFragmentDefsByPath = new Map();
+    var firstVisitMadeChanges = false;
+    var fieldOrInlineFragmentVisitor = {
+        enter: function (node) {
+            if (shouldRemoveField(node.directives)) {
+                firstVisitMadeChanges = true;
+                return null;
+            }
+        },
+    };
+    var docWithoutDirectiveSubtrees = graphql.visit(doc, {
+        Field: fieldOrInlineFragmentVisitor,
+        InlineFragment: fieldOrInlineFragmentVisitor,
+        VariableDefinition: {
+            enter: function () {
+                return false;
+            },
+        },
         Variable: {
-            enter: function (node, _key, parent) {
-                if (parent.kind !== 'VariableDefinition') {
-                    variablesInUse[node.name.value] = true;
+            enter: function (node, _key, _parent, _path, ancestors) {
+                var inUse = getInUse(ancestors);
+                if (inUse) {
+                    inUse.variables.add(node.name.value);
                 }
             },
         },
-        Field: {
-            enter: function (node) {
-                if (directives && node.directives) {
-                    var shouldRemoveField = directives.some(function (directive) { return directive.remove; });
-                    if (shouldRemoveField &&
-                        node.directives &&
-                        node.directives.some(getDirectiveMatcher(directives))) {
-                        if (node.arguments) {
-                            node.arguments.forEach(function (arg) {
-                                if (arg.value.kind === 'Variable') {
-                                    variablesToRemove.push({
-                                        name: arg.value.name.value,
-                                    });
-                                }
-                            });
-                        }
-                        if (node.selectionSet) {
-                            getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(function (frag) {
-                                fragmentSpreadsToRemove.push({
-                                    name: frag.name.value,
-                                });
-                            });
-                        }
-                        return null;
-                    }
+        FragmentSpread: {
+            enter: function (node, _key, _parent, _path, ancestors) {
+                if (shouldRemoveField(node.directives)) {
+                    firstVisitMadeChanges = true;
+                    return null;
+                }
+                var inUse = getInUse(ancestors);
+                if (inUse) {
+                    inUse.fragmentSpreads.add(node.name.value);
                 }
             },
         },
-        FragmentSpread: {
-            enter: function (node) {
-                fragmentSpreadsInUse[node.name.value] = true;
+        FragmentDefinition: {
+            enter: function (node, _key, _parent, path) {
+                originalFragmentDefsByPath.set(JSON.stringify(path), node);
+            },
+            leave: function (node, _key, _parent, path) {
+                var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));
+                if (node === originalNode) {
+                    return node;
+                }
+                if (operationCount > 0 &&
+                    node.selectionSet.selections.every(function (selection) { return (selection.kind === graphql.Kind.FIELD &&
+                        selection.name.value === '__typename'); })) {
+                    getInUseByFragmentName(node.name.value).removed = true;
+                    firstVisitMadeChanges = true;
+                    return null;
+                }
             },
         },
         Directive: {
-            enter: function (node) {
-                if (getDirectiveMatcher(directives)(node)) {
+            leave: function (node) {
+                if (directiveMatcher(node)) {
+                    firstVisitMadeChanges = true;
                     return null;
                 }
             },
         },
+    });
+    if (!firstVisitMadeChanges) {
+        return doc;
+    }
+    var populateTransitiveVars = function (inUse) {
+        if (!inUse.transitiveVars) {
+            inUse.transitiveVars = new Set(inUse.variables);
+            if (!inUse.removed) {
+                inUse.fragmentSpreads.forEach(function (childFragmentName) {
+                    populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach(function (varName) {
+                        inUse.transitiveVars.add(varName);
+                    });
+                });
+            }
+        }
+        return inUse;
+    };
+    var allFragmentNamesUsed = new Set();
+    docWithoutDirectiveSubtrees.definitions.forEach(function (def) {
+        if (def.kind === graphql.Kind.OPERATION_DEFINITION) {
+            populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function (childFragmentName) {
+                allFragmentNamesUsed.add(childFragmentName);
+            });
+        }
+        else if (def.kind === graphql.Kind.FRAGMENT_DEFINITION &&
+            operationCount === 0 &&
+            !getInUseByFragmentName(def.name.value).removed) {
+            allFragmentNamesUsed.add(def.name.value);
+        }
+    });
+    allFragmentNamesUsed.forEach(function (fragmentName) {
+        populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function (childFragmentName) {
+            allFragmentNamesUsed.add(childFragmentName);
+        });
+    });
+    var fragmentWillBeRemoved = function (fragmentName) { return !!(!allFragmentNamesUsed.has(fragmentName) ||
+        getInUseByFragmentName(fragmentName).removed); };
+    var enterVisitor = {
+        enter: function (node) {
+            if (fragmentWillBeRemoved(node.name.value)) {
+                return null;
+            }
+        },
+    };
+    return nullIfDocIsEmpty(graphql.visit(docWithoutDirectiveSubtrees, {
+        FragmentSpread: enterVisitor,
+        FragmentDefinition: enterVisitor,
+        OperationDefinition: {
+            leave: function (node) {
+                if (node.variableDefinitions) {
+                    var usedVariableNames_1 = populateTransitiveVars(getInUseByOperationName(node.name && node.name.value)).transitiveVars;
+                    if (usedVariableNames_1.size < node.variableDefinitions.length) {
+                        return tslib.__assign(tslib.__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) { return usedVariableNames_1.has(varDef.variable.name.value); }) });
+                    }
+                }
+            },
+        },
     }));
-    if (modifiedDoc &&
-        filterInPlace(variablesToRemove, function (v) { return !!v.name && !variablesInUse[v.name]; }).length) {
-        modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);
-    }
-    if (modifiedDoc &&
-        filterInPlace(fragmentSpreadsToRemove, function (fs) { return !!fs.name && !fragmentSpreadsInUse[fs.name]; })
-            .length) {
-        modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);
-    }
-    return modifiedDoc;
 }
 var addTypenameToDocument = Object.assign(function (doc) {
     return graphql.visit(doc, {
         SelectionSet: {
             enter: function (node, _key, parent) {
                 if (parent &&
-                    parent.kind === 'OperationDefinition') {
+                    parent.kind === graphql.Kind.OPERATION_DEFINITION) {
                     return;
                 }
                 var selections = node.selections;
@@ -590,78 +712,6 @@ var connectionRemoveConfig = {
 function removeConnectionDirectiveFromDocument(doc) {
     return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));
 }
-function getArgumentMatcher(config) {
-    return function argumentMatcher(argument) {
-        return config.some(function (aConfig) {
-            return argument.value &&
-                argument.value.kind === 'Variable' &&
-                argument.value.name &&
-                (aConfig.name === argument.value.name.value ||
-                    (aConfig.test && aConfig.test(argument)));
-        });
-    };
-}
-function removeArgumentsFromDocument(config, doc) {
-    var argMatcher = getArgumentMatcher(config);
-    return nullIfDocIsEmpty(graphql.visit(doc, {
-        OperationDefinition: {
-            enter: function (node) {
-                return tslib.__assign(tslib.__assign({}, node), { variableDefinitions: node.variableDefinitions ? node.variableDefinitions.filter(function (varDef) {
-                        return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });
-                    }) : [] });
-            },
-        },
-        Field: {
-            enter: function (node) {
-                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });
-                if (shouldRemoveField) {
-                    var argMatchCount_1 = 0;
-                    if (node.arguments) {
-                        node.arguments.forEach(function (arg) {
-                            if (argMatcher(arg)) {
-                                argMatchCount_1 += 1;
-                            }
-                        });
-                    }
-                    if (argMatchCount_1 === 1) {
-                        return null;
-                    }
-                }
-            },
-        },
-        Argument: {
-            enter: function (node) {
-                if (argMatcher(node)) {
-                    return null;
-                }
-            },
-        },
-    }));
-}
-function removeFragmentSpreadFromDocument(config, doc) {
-    function enter(node) {
-        if (config.some(function (def) { return def.name === node.name.value; })) {
-            return null;
-        }
-    }
-    return nullIfDocIsEmpty(graphql.visit(doc, {
-        FragmentSpread: { enter: enter },
-        FragmentDefinition: { enter: enter },
-    }));
-}
-function getAllFragmentSpreadsFromSelectionSet(selectionSet) {
-    var allFragments = [];
-    selectionSet.selections.forEach(function (selection) {
-        if ((isField(selection) || isInlineFragment(selection)) &&
-            selection.selectionSet) {
-            getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(function (frag) { return allFragments.push(frag); });
-        }
-        else if (selection.kind === 'FragmentSpread') {
-            allFragments.push(selection);
-        }
-    });
-    return allFragments;
-}
 function buildQueryFromSelectionSet(document) {
     var definition = getMainDefinition(document);
     var definitionOperation = definition.operation;
@@ -685,22 +735,6 @@ function removeClientSetsFromDocument(document) {
             remove: true,
         },
     ], document);
-    if (modifiedDoc) {
-        modifiedDoc = graphql.visit(modifiedDoc, {
-            FragmentDefinition: {
-                enter: function (node) {
-                    if (node.selectionSet) {
-                        var isTypenameOnly = node.selectionSet.selections.every(function (selection) {
-                            return isField(selection) && selection.name.value === '__typename';
-                        });
-                        if (isTypenameOnly) {
-                            return null;
-                        }
-                    }
-                },
-            },
-        });
-    }
     return modifiedDoc;
 }
 
@@ -953,9 +987,9 @@ var Concast = (function (_super) {
                 }
             },
             complete: function () {
-                var sub = _this.sub;
+                var _a = _this, sub = _a.sub, _b = _a.sources, sources = _b === void 0 ? [] : _b;
                 if (sub !== null) {
-                    var value = _this.sources.shift();
+                    var value = sources.shift();
                     if (!value) {
                         if (sub)
                             setTimeout(function () { return sub.unsubscribe(); });
@@ -1049,10 +1083,6 @@ var Concast = (function (_super) {
 }(zenObservableTs.Observable));
 fixObservableSubclass(Concast);
 
-function isNonEmptyArray(value) {
-    return Array.isArray(value) && value.length > 0;
-}
-
 function isExecutionPatchIncrementalResult(value) {
     return "incremental" in value;
 }
@@ -1141,6 +1171,26 @@ function mergeOptions(defaults, options) {
     });
 }
 
+function isNodeResponse(value) {
+    return !!value.body;
+}
+function isReadableStream(value) {
+    return !!value.getReader;
+}
+function isAsyncIterableIterator(value) {
+    return !!(canUseAsyncIteratorSymbol &&
+        value[Symbol.asyncIterator]);
+}
+function isStreamableBlob(value) {
+    return !!value.stream;
+}
+function isBlob(value) {
+    return !!value.arrayBuffer;
+}
+function isNodeReadableStream(value) {
+    return !!value.pipe;
+}
+
 function fromError(errorValue) {
     return new zenObservableTs.Observable(function (observer) {
         observer.error(errorValue);
@@ -1196,7 +1246,7 @@ function validateOperation(operation) {
     for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {
         var key = _a[_i];
         if (OPERATION_FIELDS.indexOf(key) < 0) {
-            throw __DEV__ ? new tsInvariant.InvariantError("illegal argument: ".concat(key)) : new tsInvariant.InvariantError(26);
+            throw __DEV__ ? new tsInvariant.InvariantError("illegal argument: ".concat(key)) : new tsInvariant.InvariantError(27);
         }
     }
     return operation;
@@ -1319,7 +1369,7 @@ var ApolloLink = (function () {
         return ApolloLink.concat(this, next);
     };
     ApolloLink.prototype.request = function (operation, forward) {
-        throw __DEV__ ? new tsInvariant.InvariantError('request is not implemented') : new tsInvariant.InvariantError(21);
+        throw __DEV__ ? new tsInvariant.InvariantError('request is not implemented') : new tsInvariant.InvariantError(22);
     };
     ApolloLink.prototype.onError = function (error, observer) {
         if (observer && observer.error) {
@@ -1345,27 +1395,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.8.0-alpha.1';
-
-function isNodeResponse(value) {
-    return !!value.body;
-}
-function isReadableStream(value) {
-    return !!value.getReader;
-}
-function isAsyncIterableIterator(value) {
-    return !!(canUseAsyncIteratorSymbol &&
-        value[Symbol.asyncIterator]);
-}
-function isStreamableBlob(value) {
-    return !!value.stream;
-}
-function isBlob(value) {
-    return !!value.arrayBuffer;
-}
-function isNodeReadableStream(value) {
-    return !!value.pipe;
-}
+var version = '3.8.0-alpha.10';
 
 function asyncIterator(source) {
     var _a;
@@ -1661,7 +1691,7 @@ var serializeFetchParameter = function (p, label) {
         serialized = JSON.stringify(p);
     }
     catch (e) {
-        var parseError = __DEV__ ? new tsInvariant.InvariantError("Network request failed. ".concat(label, " is not serializable: ").concat(e.message)) : new tsInvariant.InvariantError(23);
+        var parseError = __DEV__ ? new tsInvariant.InvariantError("Network request failed. ".concat(label, " is not serializable: ").concat(e.message)) : new tsInvariant.InvariantError(24);
         parseError.parseError = e;
         throw parseError;
     }
@@ -1709,7 +1739,9 @@ function selectHttpOptionsAndBodyInternal(operation, printer) {
         }
         http = tslib.__assign(tslib.__assign({}, http), config.http);
     });
-    options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);
+    if (options.headers) {
+        options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);
+    }
     var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;
     var body = { operationName: operationName, variables: variables };
     if (http.includeExtensions)
@@ -1742,7 +1774,7 @@ function removeDuplicateHeaders(headers, preserveHeaderCase) {
 
 var checkFetcher = function (fetcher) {
     if (!fetcher && typeof fetch === 'undefined') {
-        throw __DEV__ ? new tsInvariant.InvariantError("\n\"fetch\" has not been found globally and no fetcher has been configured. To fix this, install a fetch package (like https://www.npmjs.com/package/cross-fetch), instantiate the fetcher, and pass it into your HttpLink constructor. For example:\n\nimport fetch from 'cross-fetch';\nimport { ApolloClient, HttpLink } from '@apollo/client';\nconst client = new ApolloClient({\n  link: new HttpLink({ uri: '/graphql', fetch })\n});\n    ") : new tsInvariant.InvariantError(22);
+        throw __DEV__ ? new tsInvariant.InvariantError("\n\"fetch\" has not been found globally and no fetcher has been configured. To fix this, install a fetch package (like https://www.npmjs.com/package/cross-fetch), instantiate the fetcher, and pass it into your HttpLink constructor. For example:\n\nimport fetch from 'cross-fetch';\nimport { ApolloClient, HttpLink } from '@apollo/client';\nconst client = new ApolloClient({\n  link: new HttpLink({ uri: '/graphql', fetch })\n});\n    ") : new tsInvariant.InvariantError(23);
     }
 };
 
@@ -1843,6 +1875,13 @@ var createHttpLink = function (linkOptions) {
             credentials: context.credentials,
             headers: contextHeaders,
         };
+        if (hasDirectives(['client'], operation.query)) {
+            var transformedQuery = removeClientSetsFromDocument(operation.query);
+            if (!transformedQuery) {
+                return fromError(new Error('HttpLink: Trying to send a client-only query to the server. To send to the server, ensure a non-client field is added to the query or set the `transformOptions.removeClientFields` option to `true`.'));
+            }
+            operation.query = transformedQuery;
+        }
         var _b = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;
         if (body.variables && !includeUnusedVariables) {
             var unusedNames_1 = new Set(Object.keys(body.variables));
@@ -1875,6 +1914,7 @@ var createHttpLink = function (linkOptions) {
             options.method = 'GET';
         }
         if (hasDirectives(['defer'], operation.query)) {
+            options.headers = options.headers || {};
             options.headers.accept = "multipart/mixed; deferSpec=20220824, application/json";
         }
         if (options.method === 'GET') {
@@ -2038,7 +2078,6 @@ var hasOwn = Object.prototype.hasOwnProperty;
 function isNullish(value) {
     return value === null || value === void 0;
 }
-var isArray = Array.isArray;
 function defaultDataIdFromObject(_a, context) {
     var __typename = _a.__typename, id = _a.id, _id = _a._id;
     if (typeof __typename === "string") {
@@ -3282,9 +3321,20 @@ var Policies = (function () {
         if (!hasOwn.call(this.typePolicies, typename)) {
             var policy_1 = this.typePolicies[typename] = Object.create(null);
             policy_1.fields = Object.create(null);
-            var supertypes = this.supertypeMap.get(typename);
-            if (supertypes && supertypes.size) {
-                supertypes.forEach(function (supertype) {
+            var supertypes_1 = this.supertypeMap.get(typename);
+            if (!supertypes_1 && this.fuzzySubtypes.size) {
+                supertypes_1 = this.getSupertypeSet(typename, true);
+                this.fuzzySubtypes.forEach(function (regExp, fuzzy) {
+                    if (regExp.test(typename)) {
+                        var fuzzySupertypes = _this.supertypeMap.get(fuzzy);
+                        if (fuzzySupertypes) {
+                            fuzzySupertypes.forEach(function (supertype) { return supertypes_1.add(supertype); });
+                        }
+                    }
+                });
+            }
+            if (supertypes_1 && supertypes_1.size) {
+                supertypes_1.forEach(function (supertype) {
                     var _a = _this.getTypePolicy(supertype), fields = _a.fields, rest = tslib.__rest(_a, ["fields"]);
                     Object.assign(policy_1, rest);
                     Object.assign(policy_1.fields, fields);
@@ -4620,7 +4670,7 @@ var ObservableQuery = (function (_super) {
             pollingInfo.interval === pollInterval) {
             return;
         }
-        __DEV__ ? tsInvariant.invariant(pollInterval, 'Attempted to start a polling query without a polling interval.') : tsInvariant.invariant(pollInterval, 12);
+        __DEV__ ? tsInvariant.invariant(pollInterval, 'Attempted to start a polling query without a polling interval.') : tsInvariant.invariant(pollInterval, 13);
         var info = pollingInfo || (this.pollingInfo = {});
         info.interval = pollInterval;
         var maybeFetch = function () {
@@ -4769,6 +4819,7 @@ function logMissingFieldErrors(missing) {
 var LocalState = (function () {
     function LocalState(_a) {
         var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;
+        this.selectionsToResolveCache = new WeakMap();
         this.cache = cache;
         if (client) {
             this.client = client;
@@ -4824,8 +4875,12 @@ var LocalState = (function () {
         }
         return null;
     };
-    LocalState.prototype.serverQuery = function (document) {
-        return removeClientSetsFromDocument(document);
+    LocalState.prototype.serverQuery = function (document, options) {
+        if (options === void 0) { options = Object.create(null); }
+        var _a = options.removeClientFields, removeClientFields = _a === void 0 ? true : _a;
+        return removeClientFields
+            ? removeClientSetsFromDocument(document)
+            : document;
     };
     LocalState.prototype.prepareContext = function (context) {
         var cache = this.cache;
@@ -4879,13 +4934,13 @@ var LocalState = (function () {
         if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }
         if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;
+            var mainDefinition, fragments, fragmentMap, selectionsToResolve, definitionOperation, defaultOperationType, _a, cache, client, execContext, isClientFieldDescendant;
             return tslib.__generator(this, function (_b) {
                 mainDefinition = getMainDefinition(document);
                 fragments = getFragmentDefinitions(document);
                 fragmentMap = createFragmentMap(fragments);
-                definitionOperation = mainDefinition
-                    .operation;
+                selectionsToResolve = this.collectSelectionsToResolve(mainDefinition, fragmentMap);
+                definitionOperation = mainDefinition.operation;
                 defaultOperationType = definitionOperation
                     ? definitionOperation.charAt(0).toUpperCase() +
                         definitionOperation.slice(1)
@@ -4898,16 +4953,18 @@ var LocalState = (function () {
                     fragmentMatcher: fragmentMatcher,
                     defaultOperationType: defaultOperationType,
                     exportedVariables: {},
+                    selectionsToResolve: selectionsToResolve,
                     onlyRunForcedResolvers: onlyRunForcedResolvers,
                 };
-                return [2, this.resolveSelectionSet(mainDefinition.selectionSet, rootValue, execContext).then(function (result) { return ({
+                isClientFieldDescendant = false;
+                return [2, this.resolveSelectionSet(mainDefinition.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (result) { return ({
                         result: result,
                         exportedVariables: execContext.exportedVariables,
                     }); })];
             });
         });
     };
-    LocalState.prototype.resolveSelectionSet = function (selectionSet, rootValue, execContext) {
+    LocalState.prototype.resolveSelectionSet = function (selectionSet, isClientFieldDescendant, rootValue, execContext) {
         return tslib.__awaiter(this, void 0, void 0, function () {
             var fragmentMap, context, variables, resultsToMerge, execute;
             var _this = this;
@@ -4917,11 +4974,14 @@ var LocalState = (function () {
                 execute = function (selection) { return tslib.__awaiter(_this, void 0, void 0, function () {
                     var fragment, typeCondition;
                     return tslib.__generator(this, function (_a) {
+                        if (!isClientFieldDescendant && !execContext.selectionsToResolve.has(selection)) {
+                            return [2];
+                        }
                         if (!shouldInclude(selection, variables)) {
                             return [2];
                         }
                         if (isField(selection)) {
-                            return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {
+                            return [2, this.resolveField(selection, isClientFieldDescendant, rootValue, execContext).then(function (fieldResult) {
                                     var _a;
                                     if (typeof fieldResult !== 'undefined') {
                                         resultsToMerge.push((_a = {},
@@ -4940,7 +5000,7 @@ var LocalState = (function () {
                         if (fragment && fragment.typeCondition) {
                             typeCondition = fragment.typeCondition.name.value;
                             if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {
-                                return [2, this.resolveSelectionSet(fragment.selectionSet, rootValue, execContext).then(function (fragmentResult) {
+                                return [2, this.resolveSelectionSet(fragment.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (fragmentResult) {
                                         resultsToMerge.push(fragmentResult);
                                     })];
                             }
@@ -4954,11 +5014,14 @@ var LocalState = (function () {
             });
         });
     };
-    LocalState.prototype.resolveField = function (field, rootValue, execContext) {
+    LocalState.prototype.resolveField = function (field, isClientFieldDescendant, rootValue, execContext) {
         return tslib.__awaiter(this, void 0, void 0, function () {
             var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;
             var _this = this;
             return tslib.__generator(this, function (_a) {
+                if (!rootValue) {
+                    return [2, null];
+                }
                 variables = execContext.variables;
                 fieldName = field.name.value;
                 aliasedFieldName = resultKeyNameFromField(field);
@@ -4982,6 +5045,7 @@ var LocalState = (function () {
                     }
                 }
                 return [2, resultPromise.then(function (result) {
+                        var _a, _b;
                         if (result === void 0) { result = defaultResult; }
                         if (field.directives) {
                             field.directives.forEach(function (directive) {
@@ -5000,30 +5064,70 @@ var LocalState = (function () {
                         if (result == null) {
                             return result;
                         }
+                        var isClientField = (_b = (_a = field.directives) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.name.value === 'client'; })) !== null && _b !== void 0 ? _b : false;
                         if (Array.isArray(result)) {
-                            return _this.resolveSubSelectedArray(field, result, execContext);
+                            return _this.resolveSubSelectedArray(field, isClientFieldDescendant || isClientField, result, execContext);
                         }
                         if (field.selectionSet) {
-                            return _this.resolveSelectionSet(field.selectionSet, result, execContext);
+                            return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant || isClientField, result, execContext);
                         }
                     })];
             });
         });
     };
-    LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {
+    LocalState.prototype.resolveSubSelectedArray = function (field, isClientFieldDescendant, result, execContext) {
         var _this = this;
         return Promise.all(result.map(function (item) {
             if (item === null) {
                 return null;
             }
             if (Array.isArray(item)) {
-                return _this.resolveSubSelectedArray(field, item, execContext);
+                return _this.resolveSubSelectedArray(field, isClientFieldDescendant, item, execContext);
             }
             if (field.selectionSet) {
-                return _this.resolveSelectionSet(field.selectionSet, item, execContext);
+                return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant, item, execContext);
             }
         }));
     };
+    LocalState.prototype.collectSelectionsToResolve = function (mainDefinition, fragmentMap) {
+        var isSingleASTNode = function (node) { return !Array.isArray(node); };
+        var selectionsToResolveCache = this.selectionsToResolveCache;
+        function collectByDefinition(definitionNode) {
+            if (!selectionsToResolveCache.has(definitionNode)) {
+                var matches_1 = new Set();
+                selectionsToResolveCache.set(definitionNode, matches_1);
+                graphql.visit(definitionNode, {
+                    Directive: function (node, _, __, ___, ancestors) {
+                        if (node.name.value === 'client') {
+                            ancestors.forEach(function (node) {
+                                if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {
+                                    matches_1.add(node);
+                                }
+                            });
+                        }
+                    },
+                    FragmentSpread: function (spread, _, __, ___, ancestors) {
+                        var fragment = fragmentMap[spread.name.value];
+                        __DEV__ ? tsInvariant.invariant(fragment, "No fragment named ".concat(spread.name.value)) : tsInvariant.invariant(fragment, 12);
+                        var fragmentSelections = collectByDefinition(fragment);
+                        if (fragmentSelections.size > 0) {
+                            ancestors.forEach(function (node) {
+                                if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {
+                                    matches_1.add(node);
+                                }
+                            });
+                            matches_1.add(spread);
+                            fragmentSelections.forEach(function (selection) {
+                                matches_1.add(selection);
+                            });
+                        }
+                    }
+                });
+            }
+            return selectionsToResolveCache.get(definitionNode);
+        }
+        return collectByDefinition(mainDefinition);
+    };
     return LocalState;
 }());
 
@@ -5334,7 +5438,7 @@ var QueryManager = (function () {
         this.queries.forEach(function (_info, queryId) {
             _this.stopQueryNoBroadcast(queryId);
         });
-        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('QueryManager stopped while query was in flight') : new tsInvariant.InvariantError(13));
+        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('QueryManager stopped while query was in flight') : new tsInvariant.InvariantError(14));
     };
     QueryManager.prototype.cancelPendingFetches = function (error) {
         this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });
@@ -5348,10 +5452,10 @@ var QueryManager = (function () {
             return tslib.__generator(this, function (_j) {
                 switch (_j.label) {
                     case 0:
-                        __DEV__ ? tsInvariant.invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.') : tsInvariant.invariant(mutation, 14);
+                        __DEV__ ? tsInvariant.invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.') : tsInvariant.invariant(mutation, 15);
                         __DEV__ ? tsInvariant.invariant(fetchPolicy === 'network-only' ||
                             fetchPolicy === 'no-cache', "Mutations support only 'network-only' or 'no-cache' fetchPolicy strings. The default `network-only` behavior automatically writes mutation results to the cache. Passing `no-cache` skips the cache write.") : tsInvariant.invariant(fetchPolicy === 'network-only' ||
-                            fetchPolicy === 'no-cache', 15);
+                            fetchPolicy === 'no-cache', 16);
                         mutationId = this.generateMutationId();
                         _h = this.transform(mutation), document = _h.document, hasClientExports = _h.hasClientExports;
                         mutation = this.cache.transformForLink(document);
@@ -5468,7 +5572,10 @@ var QueryManager = (function () {
                     optimistic: false,
                     returnPartialData: true,
                 });
-                var mergedData = mergeIncrementalData(diff.result, result);
+                var mergedData = void 0;
+                if (diff.result) {
+                    mergedData = mergeIncrementalData(diff.result, result);
+                }
                 if (typeof mergedData !== 'undefined') {
                     result.data = mergedData;
                     cacheWrites.push({
@@ -5612,11 +5719,13 @@ var QueryManager = (function () {
     };
     QueryManager.prototype.transform = function (document) {
         var transformCache = this.transformCache;
+        var _a = (this.defaultOptions.transformQuery || Object.create(null)).removeClientFields, removeClientFields = _a === void 0 ? true : _a;
         if (!transformCache.has(document)) {
             var transformed = this.cache.transformDocument(document);
             var noConnection = removeConnectionDirectiveFromDocument(transformed);
             var clientQuery = this.localState.clientQuery(transformed);
-            var serverQuery = noConnection && this.localState.serverQuery(noConnection);
+            var serverQuery = noConnection &&
+                this.localState.serverQuery(noConnection, { removeClientFields: removeClientFields });
             var cacheEntry_1 = {
                 document: transformed,
                 hasClientExports: hasClientExports(transformed),
@@ -5670,10 +5779,10 @@ var QueryManager = (function () {
         var _this = this;
         if (queryId === void 0) { queryId = this.generateQueryId(); }
         __DEV__ ? tsInvariant.invariant(options.query, 'query option is required. You must specify your GraphQL document ' +
-            'in the query option.') : tsInvariant.invariant(options.query, 16);
-        __DEV__ ? tsInvariant.invariant(options.query.kind === 'Document', 'You must wrap the query string in a "gql" tag.') : tsInvariant.invariant(options.query.kind === 'Document', 17);
-        __DEV__ ? tsInvariant.invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.') : tsInvariant.invariant(!options.returnPartialData, 18);
-        __DEV__ ? tsInvariant.invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.') : tsInvariant.invariant(!options.pollInterval, 19);
+            'in the query option.') : tsInvariant.invariant(options.query, 17);
+        __DEV__ ? tsInvariant.invariant(options.query.kind === 'Document', 'You must wrap the query string in a "gql" tag.') : tsInvariant.invariant(options.query.kind === 'Document', 18);
+        __DEV__ ? tsInvariant.invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.') : tsInvariant.invariant(!options.returnPartialData, 19);
+        __DEV__ ? tsInvariant.invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.') : tsInvariant.invariant(!options.pollInterval, 20);
         return this.fetchQuery(queryId, options).finally(function () { return _this.stopQuery(queryId); });
     };
     QueryManager.prototype.generateQueryId = function () {
@@ -5698,7 +5807,7 @@ var QueryManager = (function () {
         if (options === void 0) { options = {
             discardWatches: true,
         }; }
-        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('Store reset while query was in flight (not completed in link chain)') : new tsInvariant.InvariantError(20));
+        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('Store reset while query was in flight (not completed in link chain)') : new tsInvariant.InvariantError(21));
         this.queries.forEach(function (queryInfo) {
             if (queryInfo.observableQuery) {
                 queryInfo.networkStatus = exports.NetworkStatus.loading;
@@ -6086,6 +6195,11 @@ var QueryManager = (function () {
                     onlyRunForcedResolvers: true,
                 }).then(function (resolved) { return fromData(resolved.data || void 0); });
             }
+            if (errorPolicy === 'none' &&
+                networkStatus === exports.NetworkStatus.refetch &&
+                Array.isArray(diff.missing)) {
+                return fromData(void 0);
+            }
             return fromData(data);
         };
         var cacheWriteBehavior = fetchPolicy === "no-cache" ? 0 :
@@ -6310,12 +6424,18 @@ var ApolloClient = (function () {
         return this.cache.readFragment(options, optimistic);
     };
     ApolloClient.prototype.writeQuery = function (options) {
-        this.cache.writeQuery(options);
-        this.queryManager.broadcastQueries();
+        var ref = this.cache.writeQuery(options);
+        if (options.broadcast !== false) {
+            this.queryManager.broadcastQueries();
+        }
+        return ref;
     };
     ApolloClient.prototype.writeFragment = function (options) {
-        this.cache.writeFragment(options);
-        this.queryManager.broadcastQueries();
+        var ref = this.cache.writeFragment(options);
+        if (options.broadcast !== false) {
+            this.queryManager.broadcastQueries();
+        }
+        return ref;
     };
     ApolloClient.prototype.__actionHookForDevTools = function (cb) {
         this.devToolsHookCb = cb;
@@ -6422,7 +6542,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, 27);
+            'Wrap the root component in an <ApolloProvider>.') : tsInvariant.invariant(context && context.client, 28);
         return props.children(context.client);
     }));
 };
@@ -6439,7 +6559,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, 28);
+            'sure you pass in your client via the "client" prop.') : tsInvariant.invariant(context.client, 29);
         return (React__namespace.createElement(ApolloContext.Provider, { value: context }, children));
     }));
 };
@@ -6449,7 +6569,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, 31);
+        'instance in via options.') : tsInvariant.invariant(!!client, 32);
     return client;
 }
 
@@ -6527,7 +6647,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, 34);
+        "to convert your operation into a document") : tsInvariant.invariant(!!document && !!document.kind, 35);
     var fragments = [];
     var queries = [];
     var mutations = [];
@@ -6555,11 +6675,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), 35);
+        (queries.length || mutations.length || subscriptions.length), 36);
     __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, 36);
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(queries.length + mutations.length + subscriptions.length <= 1, 37);
     type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;
     if (!queries.length && !mutations.length)
         type = exports.DocumentType.Subscription;
@@ -6570,7 +6690,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, 37);
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(definitions.length === 1, 38);
     var definition = definitions[0];
     variables = definition.variableDefinitions || [];
     if (definition.name && definition.name.kind === 'Name') {
@@ -6588,7 +6708,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, 38);
+        "".concat(requiredOperationName, ", but a ").concat(usedOperationName, " was used instead.")) : tsInvariant.invariant(operation.type === type, 39);
 }
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -6639,11 +6759,19 @@ var InternalState = (function () {
     InternalState.prototype.forceUpdate = function () {
         __DEV__ && tsInvariant.invariant.warn("Calling default no-op implementation of InternalState#forceUpdate");
     };
-    InternalState.prototype.asyncUpdate = function () {
+    InternalState.prototype.asyncUpdate = function (signal) {
         var _this = this;
-        return new Promise(function (resolve) {
+        return new Promise(function (resolve, reject) {
+            var watchQueryOptions = _this.watchQueryOptions;
+            var handleAborted = function () {
+                _this.asyncResolveFns.delete(resolve);
+                _this.optionsToIgnoreOnce.delete(watchQueryOptions);
+                signal.removeEventListener('abort', handleAborted);
+                reject(signal.reason);
+            };
             _this.asyncResolveFns.add(resolve);
-            _this.optionsToIgnoreOnce.add(_this.watchQueryOptions);
+            _this.optionsToIgnoreOnce.add(watchQueryOptions);
+            signal.addEventListener('abort', handleAborted);
             _this.forceUpdate();
         });
     };
@@ -6693,7 +6821,7 @@ var InternalState = (function () {
                 }
             };
             var subscription = obsQuery.subscribe(onNext, onError);
-            return function () { return subscription.unsubscribe(); };
+            return function () { return setTimeout(function () { return subscription.unsubscribe(); }); };
         }, [
             obsQuery,
             this.renderPromises,
@@ -6820,9 +6948,10 @@ var InternalState = (function () {
     InternalState.prototype.handleErrorOrCompleted = function (result, previousResult) {
         var _this = this;
         if (!result.loading) {
+            var error_1 = this.toApolloError(result);
             Promise.resolve().then(function () {
-                if (result.error) {
-                    _this.onError(result.error);
+                if (error_1) {
+                    _this.onError(error_1);
                 }
                 else if (result.data &&
                     (previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus) !== result.networkStatus &&
@@ -6834,6 +6963,11 @@ var InternalState = (function () {
             });
         }
     };
+    InternalState.prototype.toApolloError = function (result) {
+        return isNonEmptyArray(result.errors)
+            ? new ApolloError({ graphQLErrors: result.errors })
+            : result.error;
+    };
     InternalState.prototype.getCurrentResult = function () {
         if (!this.result) {
             this.handleErrorOrCompleted(this.result = this.observable.getCurrentResult());
@@ -6876,11 +7010,11 @@ var EAGER_METHODS = [
     'subscribeToMore',
 ];
 function useLazyQuery(query, options) {
-    var internalState = useInternalState(useApolloClient(options && options.client), query);
+    var _a, _b;
+    var abortControllersRef = React.useRef(new Set());
     var execOptionsRef = React.useRef();
-    var merged = execOptionsRef.current
-        ? mergeOptions(options, execOptionsRef.current)
-        : options;
+    var merged = execOptionsRef.current ? mergeOptions(options, execOptionsRef.current) : options;
+    var internalState = useInternalState(useApolloClient(options && options.client), (_b = (_a = execOptionsRef.current) === null || _a === void 0 ? void 0 : _a.query) !== null && _b !== void 0 ? _b : query);
     var useQueryResult = internalState.useQuery(tslib.__assign(tslib.__assign({}, merged), { skip: !execOptionsRef.current }));
     var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||
         internalState.getDefaultFetchPolicy();
@@ -6906,14 +7040,28 @@ function useLazyQuery(query, options) {
         return eagerMethods;
     }, []);
     Object.assign(result, eagerMethods);
+    React.useEffect(function () {
+        return function () {
+            abortControllersRef.current.forEach(function (controller) {
+                controller.abort();
+            });
+        };
+    }, []);
     var execute = React.useCallback(function (executeOptions) {
+        var controller = new AbortController();
+        abortControllersRef.current.add(controller);
         execOptionsRef.current = executeOptions ? tslib.__assign(tslib.__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
             fetchPolicy: initialFetchPolicy,
         };
         var promise = internalState
-            .asyncUpdate()
-            .then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
-        promise.catch(function () { });
+            .asyncUpdate(controller.signal)
+            .then(function (queryResult) {
+            abortControllersRef.current.delete(controller);
+            return Object.assign(queryResult, eagerMethods);
+        });
+        promise.catch(function () {
+            abortControllersRef.current.delete(controller);
+        });
         return promise;
     }, []);
     return [execute, result];
@@ -6940,8 +7088,9 @@ function useMutation(mutation, options) {
     }
     var execute = React.useCallback(function (executeOptions) {
         if (executeOptions === void 0) { executeOptions = {}; }
-        var _a = ref.current, client = _a.client, options = _a.options, mutation = _a.mutation;
+        var _a = ref.current, options = _a.options, mutation = _a.mutation;
         var baseOptions = tslib.__assign(tslib.__assign({}, options), { mutation: mutation });
+        var client = executeOptions.client || ref.current.client;
         if (!ref.current.result.loading && !baseOptions.ignoreResults && ref.current.isMounted) {
             setResult(ref.current.result = {
                 loading: true,
@@ -6954,7 +7103,7 @@ function useMutation(mutation, options) {
         var mutationId = ++ref.current.mutationId;
         var clientOptions = mergeOptions(baseOptions, executeOptions);
         return client.mutate(clientOptions).then(function (response) {
-            var _a, _b, _c;
+            var _a;
             var data = response.data, errors = response.errors;
             var error = errors && errors.length > 0
                 ? new ApolloError({ graphQLErrors: errors })
@@ -6972,11 +7121,11 @@ function useMutation(mutation, options) {
                     setResult(ref.current.result = result_1);
                 }
             }
-            (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onCompleted) === null || _b === void 0 ? void 0 : _b.call(_a, response.data, clientOptions);
-            (_c = executeOptions.onCompleted) === null || _c === void 0 ? void 0 : _c.call(executeOptions, response.data, clientOptions);
+            var onCompleted = executeOptions.onCompleted || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onCompleted);
+            onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response.data, clientOptions);
             return response;
         }).catch(function (error) {
-            var _a, _b, _c, _d;
+            var _a;
             if (mutationId === ref.current.mutationId &&
                 ref.current.isMounted) {
                 var result_2 = {
@@ -6990,9 +7139,9 @@ function useMutation(mutation, options) {
                     setResult(ref.current.result = result_2);
                 }
             }
-            if (((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) || clientOptions.onError) {
-                (_c = (_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onError) === null || _c === void 0 ? void 0 : _c.call(_b, error, clientOptions);
-                (_d = executeOptions.onError) === null || _d === void 0 ? void 0 : _d.call(executeOptions, error, clientOptions);
+            var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);
+            if (onError) {
+                onError(error, clientOptions);
                 return { data: void 0, errors: error };
             }
             throw error;
@@ -7169,20 +7318,21 @@ function useFragment_experimental(options) {
     var diffOptions = tslib.__assign(tslib.__assign({}, rest), { id: typeof from === "string" ? from : cache.identify(from), query: cache["getFragmentDoc"](fragment, fragmentName), optimistic: optimistic });
     var resultRef = React.useRef();
     var latestDiff = cache.diff(diffOptions);
+    var getSnapshot = function () {
+        var latestDiffToResult = diffToResult(latestDiff);
+        return resultRef.current &&
+            equality.equal(resultRef.current.data, latestDiffToResult.data)
+            ? resultRef.current
+            : (resultRef.current = latestDiffToResult);
+    };
     return useSyncExternalStore(function (forceUpdate) {
         return cache.watch(tslib.__assign(tslib.__assign({}, diffOptions), { immediate: true, callback: function (diff) {
                 if (!equality.equal(diff, latestDiff)) {
-                    resultRef.current = diffToResult(latestDiff = diff);
+                    resultRef.current = diffToResult((latestDiff = diff));
                     forceUpdate();
                 }
             } }));
-    }, function () {
-        var latestDiffToResult = diffToResult(latestDiff);
-        return resultRef.current &&
-            equality.equal(resultRef.current.data, latestDiffToResult.data)
-            ? resultRef.current
-            : (resultRef.current = latestDiffToResult);
-    });
+    }, getSnapshot, getSnapshot);
 }
 function diffToResult(diff) {
     var result = {
@@ -7203,10 +7353,16 @@ function useDeepMemo(memoFn, deps) {
     return ref.current.value;
 }
 
-function useSuspenseCache() {
-    var suspenseCache = React.useContext(getApolloContext()).suspenseCache;
-    __DEV__ ? tsInvariant.invariant(suspenseCache, 'Could not find a "suspenseCache" in the context. Wrap the root component ' +
-        'in an <ApolloProvider> and provide a suspenseCache.') : tsInvariant.invariant(suspenseCache, 32);
+var useIsomorphicLayoutEffect = canUseLayoutEffect
+    ? React.useLayoutEffect
+    : React.useEffect;
+
+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);
     return suspenseCache;
 }
 
@@ -7221,7 +7377,7 @@ 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();
+    var suspenseCache = useSuspenseCache(options.suspenseCache);
     var client = useApolloClient(options.client);
     var watchQueryOptions = useWatchQueryOptions({ query: query, options: options, client: client });
     var previousWatchQueryOptionsRef = React.useRef(watchQueryOptions);
@@ -7235,9 +7391,9 @@ function useSuspenseQuery_experimental(query, options) {
     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 &&
-        errorPolicy === 'none' &&
-        (!deferred || !hasPartialResult)) {
+        (result.error.networkError || allowsThrownErrors)) {
         throw result.error;
     }
     if (result.loading) {
@@ -7270,28 +7426,42 @@ function useSuspenseQuery_experimental(query, options) {
             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]);
     return React.useMemo(function () {
         return {
+            client: client,
             data: result.data,
             error: errorPolicy === 'ignore' ? void 0 : toApolloError(result),
-            fetchMore: function (options) {
-                var promise = observable.fetchMore(options);
-                suspenseCache.add(query, watchQueryOptions.variables, {
-                    promise: promise,
-                    observable: observable,
-                });
-                return promise;
-            },
-            refetch: function (variables) {
-                var promise = observable.refetch(variables);
-                suspenseCache.add(query, watchQueryOptions.variables, {
-                    promise: promise,
-                    observable: observable,
-                });
-                return promise;
-            },
+            networkStatus: result.networkStatus,
+            fetchMore: fetchMore,
+            refetch: refetch,
+            subscribeToMore: subscribeToMore,
         };
-    }, [result, observable, errorPolicy]);
+    }, [
+        client,
+        fetchMore,
+        refetch,
+        result,
+        observable,
+        errorPolicy,
+        subscribeToMore,
+    ]);
 }
 function validateOptions(options) {
     var query = options.query, _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? DEFAULT_FETCH_POLICY : _a, returnPartialData = options.returnPartialData;
@@ -7300,7 +7470,7 @@ function validateOptions(options) {
     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), 33);
+    __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);
 }
 function validatePartialDataReturn(fetchPolicy, returnPartialData) {
     if (fetchPolicy === 'no-cache' && returnPartialData) {
@@ -7345,16 +7515,18 @@ function useIsDeferred(query) {
 function useObservableQueryResult(observable) {
     var resultRef = React.useRef();
     var isMountedRef = React.useRef(false);
+    var subscribeTimeoutRef = React.useRef();
     if (!resultRef.current) {
         resultRef.current = observable.getCurrentResult();
     }
-    React.useLayoutEffect(function () {
+    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();
@@ -7368,12 +7540,20 @@ function useObservableQueryResult(observable) {
                 forceUpdate();
             }
         }
-        var subscription = observable.subscribe({
-            next: handleUpdate,
-            error: handleUpdate,
+        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.unsubscribe();
+            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
         };
     }, [observable]), function () { return resultRef.current; }, function () { return resultRef.current; });
 }