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

package/apollo-client.cjs

@@ -6,7 +6,7 @@ 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 equal = require('@wry/equality');
 var zenObservableTs = require('zen-observable-ts');
 require('symbol-observable');
 var optimism = require('optimism');
@@ -15,6 +15,8 @@ var trie = require('@wry/trie');
 var graphqlTag = require('graphql-tag');
 var React = require('react');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
 function _interopNamespace(e) {
     if (e && e.__esModule) return e;
     var n = Object.create(null);
@@ -27,7 +29,9 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
+var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
 function maybe(thunk) {
     try {
@@ -178,6 +182,12 @@ function getFragmentFromSelection(selection, fragmentMap) {
 function isNonNullObject(obj) {
     return obj !== null && typeof obj === 'object';
 }
+function isPlainObject(obj) {
+    return (obj !== null &&
+        typeof obj === 'object' &&
+        (Object.getPrototypeOf(obj) === Object.prototype ||
+            Object.getPrototypeOf(obj) === null));
+}
 
 function makeReference(id) {
     return { __ref: String(id) };
@@ -285,6 +295,7 @@ var KNOWN_DIRECTIVES = [
     'client',
     'rest',
     'export',
+    'nonreactive',
 ];
 var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
     if (args &&
@@ -483,19 +494,30 @@ function nullIfDocIsEmpty(doc) {
         ? null
         : doc;
 }
-function getDirectiveMatcher(directives) {
-    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);
+function getDirectiveMatcher(configs) {
+    var names = new Map();
+    var tests = new Map();
+    configs.forEach(function (directive) {
+        if (directive) {
+            if (directive.name) {
+                names.set(directive.name, directive);
+            }
+            else if (directive.test) {
+                tests.set(directive.test, directive);
+            }
         }
     });
-    return function (directive) { return (nameSet.has(directive.name.value) ||
-        tests.some(function (test) { return test(directive); })); };
+    return function (directive) {
+        var config = names.get(directive.name.value);
+        if (!config && tests.size) {
+            tests.forEach(function (testConfig, test) {
+                if (test(directive)) {
+                    config = testConfig;
+                }
+            });
+        }
+        return config;
+    };
 }
 function makeInUseGetterFunction(defaultKey) {
     var map = new Map();
@@ -512,6 +534,7 @@ function makeInUseGetterFunction(defaultKey) {
     };
 }
 function removeDirectivesFromDocument(directives, doc) {
+    checkDocument(doc);
     var getInUseByOperationName = makeInUseGetterFunction("");
     var getInUseByFragmentName = makeInUseGetterFunction("");
     var getInUse = function (ancestors) {
@@ -535,10 +558,8 @@ function removeDirectivesFromDocument(directives, doc) {
         }
     }
     var directiveMatcher = getDirectiveMatcher(directives);
-    var hasRemoveDirective = directives.some(function (directive) { return directive.remove; });
-    var shouldRemoveField = function (nodeDirectives) { return (hasRemoveDirective &&
-        nodeDirectives &&
-        nodeDirectives.some(directiveMatcher)); };
+    var shouldRemoveField = function (nodeDirectives) { return (isNonEmptyArray(nodeDirectives) &&
+        nodeDirectives.map(directiveMatcher).some(function (config) { return config && config.remove; })); };
     var originalFragmentDefsByPath = new Map();
     var firstVisitMadeChanges = false;
     var fieldOrInlineFragmentVisitor = {
@@ -697,22 +718,6 @@ var addTypenameToDocument = Object.assign(function (doc) {
         return field === TYPENAME_FIELD;
     },
 });
-var connectionRemoveConfig = {
-    test: function (directive) {
-        var willRemove = directive.name.value === 'connection';
-        if (willRemove) {
-            if (!directive.arguments ||
-                !directive.arguments.some(function (arg) { return arg.name.value === 'key'; })) {
-                __DEV__ && tsInvariant.invariant.warn('Removing an @connection directive even though it does not have a key. ' +
-                    'You may want to use the key parameter to specify a store key.');
-            }
-        }
-        return willRemove;
-    },
-};
-function removeConnectionDirectiveFromDocument(doc) {
-    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));
-}
 function buildQueryFromSelectionSet(document) {
     var definition = getMainDefinition(document);
     var definitionOperation = definition.operation;
@@ -812,6 +817,31 @@ var DeepMerger = (function () {
     return DeepMerger;
 }());
 
+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;
+}
+
 var toString = Object.prototype.toString;
 function cloneDeep(value) {
     return cloneDeepHelper(value);
@@ -1094,6 +1124,9 @@ function isExecutionPatchResult(value) {
     return (isExecutionPatchIncrementalResult(value) ||
         isExecutionPatchInitialResult(value));
 }
+function isApolloPayloadResult(value) {
+    return isNonNullObject(value) && "payload" in value;
+}
 function mergeIncrementalData(prevResult, result) {
     var mergedData = prevResult;
     var merger = new DeepMerger();
@@ -1192,6 +1225,51 @@ function isNodeReadableStream(value) {
     return !!value.pipe;
 }
 
+function omitDeep(value, key) {
+    return __omitDeep(value, key);
+}
+function __omitDeep(value, key, known) {
+    if (known === void 0) { known = new Map(); }
+    if (known.has(value)) {
+        return known.get(value);
+    }
+    var modified = false;
+    if (Array.isArray(value)) {
+        var array_1 = [];
+        known.set(value, array_1);
+        value.forEach(function (value, index) {
+            var result = __omitDeep(value, key, known);
+            modified || (modified = result !== value);
+            array_1[index] = result;
+        });
+        if (modified) {
+            return array_1;
+        }
+    }
+    else if (isPlainObject(value)) {
+        var obj_1 = Object.create(Object.getPrototypeOf(value));
+        known.set(value, obj_1);
+        Object.keys(value).forEach(function (k) {
+            if (k === key) {
+                modified = true;
+            }
+            else {
+                var result = __omitDeep(value[k], key, known);
+                modified || (modified = result !== value[k]);
+                obj_1[k] = result;
+            }
+        });
+        if (modified) {
+            return obj_1;
+        }
+    }
+    return value;
+}
+
+function stripTypename(value) {
+    return omitDeep(value, '__typename');
+}
+
 function fromError(errorValue) {
     return new zenObservableTs.Observable(function (observer) {
         observer.error(errorValue);
@@ -1291,6 +1369,22 @@ function transformOperation(operation) {
     return transformedOperation;
 }
 
+function filterOperationVariables(variables, operation) {
+    var result = tslib.__assign({}, variables);
+    var unusedNames = new Set(Object.keys(variables));
+    graphql.visit(operation.query, {
+        Variable: function (node, _key, parent) {
+            if (parent && parent.kind !== 'VariableDefinition') {
+                unusedNames.delete(node.name.value);
+            }
+        },
+    });
+    unusedNames.forEach(function (name) {
+        delete result[name];
+    });
+    return result;
+}
+
 function passthrough(op, forward) {
     return (forward ? forward(op) : zenObservableTs.Observable.of());
 }
@@ -1396,7 +1490,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.8.0-alpha.11';
+var version = '3.8.0-alpha.12';
 
 function asyncIterator(source) {
     var _a;
@@ -1541,20 +1635,56 @@ function responseIterator(response) {
     throw new Error("Unknown body type for responseIterator. Please pass a streamable response.");
 }
 
+var PROTOCOL_ERRORS_SYMBOL = Symbol();
+function graphQLResultHasProtocolErrors(result) {
+    if (result.extensions) {
+        return Array.isArray(result.extensions[PROTOCOL_ERRORS_SYMBOL]);
+    }
+    return false;
+}
+function isApolloError(err) {
+    return err.hasOwnProperty('graphQLErrors');
+}
+var generateErrorMessage = function (err) {
+    var errors = tslib.__spreadArray(tslib.__spreadArray(tslib.__spreadArray([], err.graphQLErrors, true), err.clientErrors, true), err.protocolErrors, true);
+    if (err.networkError)
+        errors.push(err.networkError);
+    return errors
+        .map(function (err) { return isNonNullObject(err) && err.message || 'Error message not found.'; })
+        .join('\n');
+};
+var ApolloError = (function (_super) {
+    tslib.__extends(ApolloError, _super);
+    function ApolloError(_a) {
+        var graphQLErrors = _a.graphQLErrors, protocolErrors = _a.protocolErrors, clientErrors = _a.clientErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;
+        var _this = _super.call(this, errorMessage) || this;
+        _this.name = 'ApolloError';
+        _this.graphQLErrors = graphQLErrors || [];
+        _this.protocolErrors = protocolErrors || [];
+        _this.clientErrors = clientErrors || [];
+        _this.networkError = networkError || null;
+        _this.message = errorMessage || generateErrorMessage(_this);
+        _this.extraInfo = extraInfo;
+        _this.__proto__ = ApolloError.prototype;
+        return _this;
+    }
+    return ApolloError;
+}(Error));
+
 var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
 function readMultipartBody(response, observer) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     return tslib.__awaiter(this, void 0, void 0, function () {
-        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _d, value, done, chunk, bi, message, i, headers, contentType_1, body, result;
-        var _e;
-        return tslib.__generator(this, function (_f) {
-            switch (_f.label) {
+        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _f, value, done, chunk, bi, message, i, headers, contentType_1, body, result, next;
+        var _g, _h;
+        return tslib.__generator(this, function (_j) {
+            switch (_j.label) {
                 case 0:
                     if (TextDecoder === undefined) {
                         throw new Error("TextDecoder must be defined in the environment: please import a polyfill.");
                     }
                     decoder = new TextDecoder("utf-8");
-                    contentType = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get('content-type');
+                    contentType = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get("content-type");
                     delimiter = "boundary=";
                     boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter))
                         ? contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['"]/g, "").replace(/\;(.*)/gm, "").trim()
@@ -1563,22 +1693,22 @@ function readMultipartBody(response, observer) {
                     buffer = "";
                     iterator = responseIterator(response);
                     running = true;
-                    _f.label = 1;
+                    _j.label = 1;
                 case 1:
                     if (!running) return [3, 3];
                     return [4, iterator.next()];
                 case 2:
-                    _d = _f.sent(), value = _d.value, done = _d.done;
+                    _f = _j.sent(), value = _f.value, done = _f.done;
                     chunk = typeof value === "string" ? value : decoder.decode(value);
                     running = !done;
                     buffer += chunk;
                     bi = buffer.indexOf(boundary);
                     while (bi > -1) {
                         message = void 0;
-                        _e = [
+                        _g = [
                             buffer.slice(0, bi),
                             buffer.slice(bi + boundary.length),
-                        ], message = _e[0], buffer = _e[1];
+                        ], message = _g[0], buffer = _g[1];
                         if (message.trim()) {
                             i = message.indexOf("\r\n\r\n");
                             headers = parseHeaders(message.slice(0, i));
@@ -1593,8 +1723,26 @@ function readMultipartBody(response, observer) {
                                 if (Object.keys(result).length > 1 ||
                                     "data" in result ||
                                     "incremental" in result ||
-                                    "errors" in result) {
-                                    (_b = observer.next) === null || _b === void 0 ? void 0 : _b.call(observer, result);
+                                    "errors" in result ||
+                                    "payload" in result) {
+                                    if (isApolloPayloadResult(result)) {
+                                        next = {};
+                                        if ("payload" in result) {
+                                            next = tslib.__assign({}, result.payload);
+                                        }
+                                        if ("errors" in result) {
+                                            next = tslib.__assign(tslib.__assign({}, next), { extensions: tslib.__assign(tslib.__assign({}, ("extensions" in next ? next.extensions : null)), (_h = {}, _h[PROTOCOL_ERRORS_SYMBOL] = result.errors, _h)) });
+                                        }
+                                        (_b = observer.next) === null || _b === void 0 ? void 0 : _b.call(observer, next);
+                                    }
+                                    else {
+                                        (_c = observer.next) === null || _c === void 0 ? void 0 : _c.call(observer, result);
+                                    }
+                                }
+                                else if (Object.keys(result).length === 1 &&
+                                    "hasNext" in result &&
+                                    !result.hasNext) {
+                                    (_d = observer.complete) === null || _d === void 0 ? void 0 : _d.call(observer);
                                 }
                             }
                             catch (err) {
@@ -1605,7 +1753,7 @@ function readMultipartBody(response, observer) {
                     }
                     return [3, 1];
                 case 3:
-                    (_c = observer.complete) === null || _c === void 0 ? void 0 : _c.call(observer);
+                    (_e = observer.complete) === null || _e === void 0 ? void 0 : _e.call(observer);
                     return [2];
             }
         });
@@ -1744,7 +1892,7 @@ function selectHttpOptionsAndBodyInternal(operation, printer) {
         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 };
+    var body = { operationName: operationName, variables: stripTypename(variables) };
     if (http.includeExtensions)
         body.extensions = extensions;
     if (http.includeQuery)
@@ -1885,20 +2033,7 @@ var createHttpLink = function (linkOptions) {
         }
         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));
-            graphql.visit(operation.query, {
-                Variable: function (node, _key, parent) {
-                    if (parent && parent.kind !== 'VariableDefinition') {
-                        unusedNames_1.delete(node.name.value);
-                    }
-                },
-            });
-            if (unusedNames_1.size) {
-                body.variables = tslib.__assign({}, body.variables);
-                unusedNames_1.forEach(function (name) {
-                    delete body.variables[name];
-                });
-            }
+            body.variables = filterOperationVariables(body.variables, operation);
         }
         var controller;
         if (!options.signal) {
@@ -1910,13 +2045,28 @@ var createHttpLink = function (linkOptions) {
         var definitionIsMutation = function (d) {
             return d.kind === 'OperationDefinition' && d.operation === 'mutation';
         };
+        var definitionIsSubscription = function (d) {
+            return d.kind === 'OperationDefinition' && d.operation === 'subscription';
+        };
+        var isSubscription = definitionIsSubscription(getMainDefinition(operation.query));
+        var hasDefer = hasDirectives(['defer'], operation.query);
         if (useGETForQueries &&
             !operation.query.definitions.some(definitionIsMutation)) {
             options.method = 'GET';
         }
-        if (hasDirectives(['defer'], operation.query)) {
+        if (hasDefer || isSubscription) {
             options.headers = options.headers || {};
-            options.headers.accept = "multipart/mixed; deferSpec=20220824, application/json";
+            var acceptHeader = "multipart/mixed;";
+            if (isSubscription && hasDefer) {
+                __DEV__ && tsInvariant.invariant.warn("Multipart-subscriptions do not support @defer");
+            }
+            if (isSubscription) {
+                acceptHeader += 'boundary=graphql;subscriptionSpec=1.0,application/json';
+            }
+            else if (hasDefer) {
+                acceptHeader += 'deferSpec=20220824,application/json';
+            }
+            options.headers.accept = acceptHeader;
         }
         if (options.method === 'GET') {
             var _d = rewriteURIForGET(chosenURI, body), newURI = _d.newURI, parseError = _d.parseError;
@@ -2568,7 +2718,7 @@ var Layer = (function (_super) {
                     }
                     else if (ownStoreObject !== parentStoreObject) {
                         Object.keys(ownStoreObject).forEach(function (storeFieldName) {
-                            if (!equality.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
+                            if (!equal.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
                                 _this.group.dirty(dataId, storeFieldName);
                             }
                         });
@@ -2612,7 +2762,7 @@ var Stump = (function (_super) {
 function storeObjectReconciler(existingObject, incomingObject, property) {
     var existingValue = existingObject[property];
     var incomingValue = incomingObject[property];
-    return equality.equal(existingValue, incomingValue) ? existingValue : incomingValue;
+    return equal.equal(existingValue, incomingValue) ? existingValue : incomingValue;
 }
 function supportsResultCaching(store) {
     return !!(store instanceof EntityStore && store.group.caching);
@@ -3939,7 +4089,7 @@ function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
         return;
     if (isReference(existing))
         return;
-    if (equality.equal(existing, incoming))
+    if (equal.equal(existing, incoming))
         return;
     if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
         return;
@@ -4262,51 +4412,13 @@ var InMemoryCache = (function (_super) {
                 return;
             }
         }
-        if (!lastDiff || !equality.equal(lastDiff.result, diff.result)) {
+        if (!lastDiff || !equal.equal(lastDiff.result, diff.result)) {
             c.callback(c.lastDiff = diff, lastDiff);
         }
     };
     return InMemoryCache;
 }(ApolloCache));
 
-function isApolloError(err) {
-    return err.hasOwnProperty('graphQLErrors');
-}
-var generateErrorMessage = function (err) {
-    var message = '';
-    if (isNonEmptyArray(err.graphQLErrors) || isNonEmptyArray(err.clientErrors)) {
-        var errors = (err.graphQLErrors || [])
-            .concat(err.clientErrors || []);
-        errors.forEach(function (error) {
-            var errorMessage = error
-                ? error.message
-                : 'Error message not found.';
-            message += "".concat(errorMessage, "\n");
-        });
-    }
-    if (err.networkError) {
-        message += "".concat(err.networkError.message, "\n");
-    }
-    message = message.replace(/\n$/, '');
-    return message;
-};
-var ApolloError = (function (_super) {
-    tslib.__extends(ApolloError, _super);
-    function ApolloError(_a) {
-        var graphQLErrors = _a.graphQLErrors, clientErrors = _a.clientErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;
-        var _this = _super.call(this, errorMessage) || this;
-        _this.name = 'ApolloError';
-        _this.graphQLErrors = graphQLErrors || [];
-        _this.clientErrors = clientErrors || [];
-        _this.networkError = networkError || null;
-        _this.message = errorMessage || generateErrorMessage(_this);
-        _this.extraInfo = extraInfo;
-        _this.__proto__ = ApolloError.prototype;
-        return _this;
-    }
-    return ApolloError;
-}(Error));
-
 exports.NetworkStatus = void 0;
 (function (NetworkStatus) {
     NetworkStatus[NetworkStatus["loading"] = 1] = "loading";
@@ -4324,6 +4436,70 @@ function isNetworkRequestSettled(networkStatus) {
     return networkStatus === 7 || networkStatus === 8;
 }
 
+function equalByQuery(query, _a, _b, variables) {
+    var aData = _a.data, aRest = tslib.__rest(_a, ["data"]);
+    var bData = _b.data, bRest = tslib.__rest(_b, ["data"]);
+    return equal__default(aRest, bRest) && equalBySelectionSet(getMainDefinition(query).selectionSet, aData, bData, {
+        fragmentMap: createFragmentMap(getFragmentDefinitions(query)),
+        variables: variables,
+    });
+}
+function equalBySelectionSet(selectionSet, aResult, bResult, context) {
+    if (aResult === bResult) {
+        return true;
+    }
+    var seenSelections = new Set();
+    return selectionSet.selections.every(function (selection) {
+        if (seenSelections.has(selection))
+            return true;
+        seenSelections.add(selection);
+        if (!shouldInclude(selection, context.variables))
+            return true;
+        if (selectionHasNonreactiveDirective(selection))
+            return true;
+        if (isField(selection)) {
+            var resultKey = resultKeyNameFromField(selection);
+            var aResultChild = aResult && aResult[resultKey];
+            var bResultChild = bResult && bResult[resultKey];
+            var childSelectionSet = selection.selectionSet;
+            if (!childSelectionSet) {
+                return equal__default(aResultChild, bResultChild);
+            }
+            var aChildIsArray = Array.isArray(aResultChild);
+            var bChildIsArray = Array.isArray(bResultChild);
+            if (aChildIsArray !== bChildIsArray)
+                return false;
+            if (aChildIsArray && bChildIsArray) {
+                var length_1 = aResultChild.length;
+                if (bResultChild.length !== length_1) {
+                    return false;
+                }
+                for (var i = 0; i < length_1; ++i) {
+                    if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);
+        }
+        else {
+            var fragment = getFragmentFromSelection(selection, context.fragmentMap);
+            if (fragment) {
+                if (selectionHasNonreactiveDirective(fragment))
+                    return true;
+                return equalBySelectionSet(fragment.selectionSet, aResult, bResult, context);
+            }
+        }
+    });
+}
+function selectionHasNonreactiveDirective(selection) {
+    return !!selection.directives && selection.directives.some(directiveIsNonreactive);
+}
+function directiveIsNonreactive(dir) {
+    return dir.name.value === "nonreactive";
+}
+
 var assign = Object.assign, hasOwnProperty$2 = Object.hasOwnProperty;
 var ObservableQuery = (function (_super) {
     tslib.__extends(ObservableQuery, _super);
@@ -4418,7 +4594,7 @@ var ObservableQuery = (function (_super) {
             if (diff.complete || this.options.returnPartialData) {
                 result.data = diff.result;
             }
-            if (equality.equal(result.data, {})) {
+            if (equal.equal(result.data, {})) {
                 result.data = void 0;
             }
             if (diff.complete) {
@@ -4449,15 +4625,21 @@ var ObservableQuery = (function (_super) {
         return result;
     };
     ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {
-        return (!this.last ||
-            !equality.equal(this.last.result, newResult) ||
-            (variables && !equality.equal(this.last.variables, variables)));
+        if (!this.last) {
+            return true;
+        }
+        var query = this.options.query;
+        var resultIsDifferent = this.queryManager.transform(query).hasNonreactiveDirective
+            ? !equalByQuery(query, this.last.result, newResult, this.variables)
+            : !equal.equal(this.last.result, newResult);
+        return (resultIsDifferent ||
+            (variables && !equal.equal(this.last.variables, variables)));
     };
     ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {
         var last = this.last;
         if (last &&
             last[key] &&
-            (!variablesMustMatch || equality.equal(last.variables, this.variables))) {
+            (!variablesMustMatch || equal.equal(last.variables, this.variables))) {
             return last[key];
         }
     };
@@ -4496,7 +4678,7 @@ var ObservableQuery = (function (_super) {
                 __DEV__ && tsInvariant.invariant.warn("Called refetch(".concat(JSON.stringify(variables), ") for query ").concat(((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || JSON.stringify(queryDef), ", which does not declare a $variables variable.\nDid you mean to call refetch(variables) instead of refetch({ variables })?"));
             }
         }
-        if (variables && !equality.equal(this.options.variables, variables)) {
+        if (variables && !equal.equal(this.options.variables, variables)) {
             reobserveOptions.variables = this.options.variables = tslib.__assign(tslib.__assign({}, this.options.variables), variables);
         }
         this.queryInfo.resetLastWrite();
@@ -4591,7 +4773,7 @@ var ObservableQuery = (function (_super) {
         return this.reobserve(newOptions);
     };
     ObservableQuery.prototype.setVariables = function (variables) {
-        if (equality.equal(this.variables, variables)) {
+        if (equal.equal(this.variables, variables)) {
             return this.observers.size
                 ? this.result()
                 : Promise.resolve();
@@ -4656,7 +4838,7 @@ var ObservableQuery = (function (_super) {
     };
     ObservableQuery.prototype.fetch = function (options, newNetworkStatus) {
         this.queryManager.setObservableQuery(this);
-        return this.queryManager.fetchQueryObservable(this.queryId, options, newNetworkStatus);
+        return this.queryManager['fetchConcastWithInfo'](this.queryId, options, newNetworkStatus);
     };
     ObservableQuery.prototype.updatePolling = function () {
         var _this = this;
@@ -4701,15 +4883,15 @@ var ObservableQuery = (function (_super) {
     };
     ObservableQuery.prototype.updateLastResult = function (newResult, variables) {
         if (variables === void 0) { variables = this.variables; }
-        this.last = tslib.__assign(tslib.__assign({}, this.last), { result: this.queryManager.assumeImmutableResults
-                ? newResult
-                : cloneDeep(newResult), variables: variables });
-        if (!isNonEmptyArray(newResult.errors)) {
-            delete this.last.error;
+        var error = this.getLastError();
+        if (error && this.last && !equal.equal(variables, this.last.variables)) {
+            error = void 0;
         }
-        return this.last;
+        return this.last = tslib.__assign({ result: this.queryManager.assumeImmutableResults
+                ? newResult
+                : cloneDeep(newResult), variables: variables }, (error ? { error: error } : null));
     };
-    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
+    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {
         var _this = this;
         this.isTornDown = false;
         var useDisposableConcast = newNetworkStatus === exports.NetworkStatus.refetch ||
@@ -4725,7 +4907,7 @@ var ObservableQuery = (function (_super) {
             this.updatePolling();
             if (newOptions &&
                 newOptions.variables &&
-                !equality.equal(newOptions.variables, oldVariables) &&
+                !equal.equal(newOptions.variables, oldVariables) &&
                 options.fetchPolicy !== "standby" &&
                 options.fetchPolicy === oldFetchPolicy) {
                 this.applyNextFetchPolicy("variables-changed", options);
@@ -4735,7 +4917,7 @@ var ObservableQuery = (function (_super) {
             }
         }
         var variables = options.variables && tslib.__assign({}, options.variables);
-        var concast = this.fetch(options, newNetworkStatus);
+        var _a = this.fetch(options, newNetworkStatus), concast = _a.concast, fromLink = _a.fromLink;
         var observer = {
             next: function (result) {
                 _this.reportResult(result, variables);
@@ -4744,7 +4926,7 @@ var ObservableQuery = (function (_super) {
                 _this.reportError(error, variables);
             },
         };
-        if (!useDisposableConcast) {
+        if (!useDisposableConcast && (fromLink || !this.concast)) {
             if (this.concast && this.observer) {
                 this.concast.removeObserver(this.observer);
             }
@@ -4752,18 +4934,22 @@ var ObservableQuery = (function (_super) {
             this.observer = observer;
         }
         concast.addObserver(observer);
-        return concast.promise;
+        return concast;
+    };
+    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
+        return this.reobserveAsConcast(newOptions, newNetworkStatus).promise;
     };
     ObservableQuery.prototype.observe = function () {
         this.reportResult(this.getCurrentResult(false), this.variables);
     };
     ObservableQuery.prototype.reportResult = function (result, variables) {
         var lastError = this.getLastError();
-        if (lastError || this.isDifferentFromLastResult(result, variables)) {
-            if (lastError || !result.partial || this.options.returnPartialData) {
-                this.updateLastResult(result, variables);
-            }
-            iterateObserversSafely(this.observers, 'next', result);
+        var isDifferent = this.isDifferentFromLastResult(result, variables);
+        if (lastError || !result.partial || this.options.returnPartialData) {
+            this.updateLastResult(result, variables);
+        }
+        if (lastError || isDifferent) {
+            iterateObserversSafely(this.observers, "next", result);
         }
     };
     ObservableQuery.prototype.reportError = function (error, variables) {
@@ -5172,10 +5358,10 @@ var QueryInfo = (function () {
         var networkStatus = query.networkStatus || exports.NetworkStatus.loading;
         if (this.variables &&
             this.networkStatus !== exports.NetworkStatus.loading &&
-            !equality.equal(this.variables, query.variables)) {
+            !equal.equal(this.variables, query.variables)) {
             networkStatus = exports.NetworkStatus.setVariables;
         }
-        if (!equality.equal(query.variables, this.variables)) {
+        if (!equal.equal(query.variables, this.variables)) {
             this.lastDiff = void 0;
         }
         Object.assign(this, {
@@ -5200,7 +5386,7 @@ var QueryInfo = (function () {
     QueryInfo.prototype.getDiff = function (variables) {
         if (variables === void 0) { variables = this.variables; }
         var options = this.getDiffOptions(variables);
-        if (this.lastDiff && equality.equal(options, this.lastDiff.options)) {
+        if (this.lastDiff && equal.equal(options, this.lastDiff.options)) {
             return this.lastDiff.diff;
         }
         this.updateWatch(this.variables = variables);
@@ -5234,7 +5420,7 @@ var QueryInfo = (function () {
         var oldDiff = this.lastDiff && this.lastDiff.diff;
         this.updateLastDiff(diff);
         if (!this.dirty &&
-            !equality.equal(oldDiff && oldDiff.result, diff && diff.result)) {
+            !equal.equal(oldDiff && oldDiff.result, diff && diff.result)) {
             this.dirty = true;
             if (!this.notifyTimeout) {
                 this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);
@@ -5309,7 +5495,7 @@ var QueryInfo = (function () {
         }
         var watchOptions = tslib.__assign(tslib.__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });
         if (!this.lastWatch ||
-            !equality.equal(watchOptions, this.lastWatch)) {
+            !equal.equal(watchOptions, this.lastWatch)) {
             this.cancel();
             this.cancel = this.cache.watch(this.lastWatch = watchOptions);
         }
@@ -5321,8 +5507,8 @@ var QueryInfo = (function () {
         var lastWrite = this.lastWrite;
         return !(lastWrite &&
             lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
-            equality.equal(variables, lastWrite.variables) &&
-            equality.equal(result.data, lastWrite.result.data));
+            equal.equal(variables, lastWrite.variables) &&
+            equal.equal(result.data, lastWrite.result.data));
     };
     QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {
         var _this = this;
@@ -5724,14 +5910,17 @@ var QueryManager = (function () {
         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 serverQuery = removeDirectivesFromDocument([
+                removeClientFields ? { name: 'client', remove: true } : {},
+                { name: 'connection' },
+                { name: 'nonreactive' },
+            ], transformed);
             var clientQuery = this.localState.clientQuery(transformed);
-            var serverQuery = noConnection &&
-                this.localState.serverQuery(noConnection, { removeClientFields: removeClientFields });
             var cacheEntry_1 = {
                 document: transformed,
                 hasClientExports: hasClientExports(transformed),
                 hasForcedResolvers: this.localState.shouldForceResolvers(transformed),
+                hasNonreactiveDirective: hasDirectives(['nonreactive'], transformed),
                 clientQuery: clientQuery,
                 serverQuery: serverQuery,
                 defaultVars: getDefaultValues(getOperationDefinition(transformed)),
@@ -5929,10 +6118,17 @@ var QueryManager = (function () {
                     }
                     _this.broadcastQueries();
                 }
-                if (graphQLResultHasError(result)) {
-                    throw new ApolloError({
-                        graphQLErrors: result.errors,
-                    });
+                var hasErrors = graphQLResultHasError(result);
+                var hasProtocolErrors = graphQLResultHasProtocolErrors(result);
+                if (hasErrors || hasProtocolErrors) {
+                    var errors = {};
+                    if (hasErrors) {
+                        errors.graphQLErrors = result.errors;
+                    }
+                    if (hasProtocolErrors) {
+                        errors.protocolErrors = result.extensions[PROTOCOL_ERRORS_SYMBOL];
+                    }
+                    throw new ApolloError(errors);
                 }
                 return result;
             });
@@ -6064,6 +6260,9 @@ var QueryManager = (function () {
         });
     };
     QueryManager.prototype.fetchQueryObservable = function (queryId, options, networkStatus) {
+        return this.fetchConcastWithInfo(queryId, options, networkStatus).concast;
+    };
+    QueryManager.prototype.fetchConcastWithInfo = function (queryId, options, networkStatus) {
         var _this = this;
         if (networkStatus === void 0) { networkStatus = exports.NetworkStatus.loading; }
         var query = this.transform(options.query).document;
@@ -6082,24 +6281,36 @@ var QueryManager = (function () {
         });
         var fromVariables = function (variables) {
             normalized.variables = variables;
-            var concastSources = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
+            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
             if (normalized.fetchPolicy !== "standby" &&
-                concastSources.length > 0 &&
+                sourcesWithInfo.sources.length > 0 &&
                 queryInfo.observableQuery) {
                 queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
             }
-            return concastSources;
+            return sourcesWithInfo;
         };
         var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };
         this.fetchCancelFns.set(queryId, function (reason) {
             cleanupCancelFn();
             setTimeout(function () { return concast.cancel(reason); });
         });
-        var concast = new Concast(this.transform(normalized.query).hasClientExports
-            ? this.localState.addExportedVariables(normalized.query, normalized.variables, normalized.context).then(fromVariables)
-            : fromVariables(normalized.variables));
+        var concast, containsDataFromLink;
+        if (this.transform(normalized.query).hasClientExports) {
+            concast = new Concast(this.localState
+                .addExportedVariables(normalized.query, normalized.variables, normalized.context)
+                .then(fromVariables).then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));
+            containsDataFromLink = true;
+        }
+        else {
+            var sourcesWithInfo = fromVariables(normalized.variables);
+            containsDataFromLink = sourcesWithInfo.fromLink;
+            concast = new Concast(sourcesWithInfo.sources);
+        }
         concast.promise.then(cleanupCancelFn, cleanupCancelFn);
-        return concast;
+        return {
+            concast: concast,
+            fromLink: containsDataFromLink,
+        };
     };
     QueryManager.prototype.refetchQueries = function (_a) {
         var _this = this;
@@ -6184,7 +6395,7 @@ var QueryManager = (function () {
             var data = diff.result;
             if (__DEV__ &&
                 !returnPartialData &&
-                !equality.equal(data, {})) {
+                !equal.equal(data, {})) {
                 logMissingFieldErrors(diff.missing);
             }
             var fromData = function (data) { return zenObservableTs.Observable.of(tslib.__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true }))); };
@@ -6223,54 +6434,40 @@ var QueryManager = (function () {
             case "cache-first": {
                 var diff = readCache();
                 if (diff.complete) {
-                    return [
-                        resultsFromCache(diff, queryInfo.markReady()),
-                    ];
+                    return { fromLink: false, sources: [resultsFromCache(diff, queryInfo.markReady())] };
                 }
                 if (returnPartialData || shouldNotify) {
-                    return [
-                        resultsFromCache(diff),
-                        resultsFromLink(),
-                    ];
+                    return { fromLink: true, sources: [resultsFromCache(diff), resultsFromLink()] };
                 }
-                return [
-                    resultsFromLink(),
-                ];
+                return { fromLink: true, sources: [resultsFromLink()] };
             }
             case "cache-and-network": {
                 var diff = readCache();
                 if (diff.complete || returnPartialData || shouldNotify) {
-                    return [
-                        resultsFromCache(diff),
-                        resultsFromLink(),
-                    ];
+                    return { fromLink: true, sources: [resultsFromCache(diff), resultsFromLink()] };
                 }
-                return [
-                    resultsFromLink(),
-                ];
+                return { fromLink: true, sources: [resultsFromLink()] };
             }
             case "cache-only":
-                return [
-                    resultsFromCache(readCache(), queryInfo.markReady()),
-                ];
+                return { fromLink: false, sources: [resultsFromCache(readCache(), queryInfo.markReady())] };
             case "network-only":
                 if (shouldNotify) {
-                    return [
-                        resultsFromCache(readCache()),
-                        resultsFromLink(),
-                    ];
+                    return { fromLink: true, sources: [resultsFromCache(readCache()), resultsFromLink()] };
                 }
-                return [resultsFromLink()];
+                return { fromLink: true, sources: [resultsFromLink()] };
             case "no-cache":
                 if (shouldNotify) {
-                    return [
-                        resultsFromCache(queryInfo.getDiff()),
-                        resultsFromLink(),
-                    ];
+                    return {
+                        fromLink: true,
+                        sources: [
+                            resultsFromCache(queryInfo.getDiff()),
+                            resultsFromLink(),
+                        ],
+                    };
                 }
-                return [resultsFromLink()];
+                return { fromLink: true, sources: [resultsFromLink()] };
             case "standby":
-                return [];
+                return { fromLink: false, sources: [] };
         }
     };
     QueryManager.prototype.getQuery = function (queryId) {
@@ -6577,8 +6774,8 @@ function useApolloClient(override) {
 
 var didWarnUncachedGetSnapshot = false;
 var uSESKey = "useSyncExternalStore";
-var realHook = React__namespace[uSESKey];
-var useSyncExternalStore = realHook || (function (subscribe, getSnapshot, getServerSnapshot) {
+var realHook$1 = React__namespace[uSESKey];
+var useSyncExternalStore = realHook$1 || (function (subscribe, getSnapshot, getServerSnapshot) {
     var value = getSnapshot();
     if (__DEV__ &&
         !didWarnUncachedGetSnapshot &&
@@ -6736,8 +6933,6 @@ var InternalState = (function () {
     function InternalState(client, query, previous) {
         this.client = client;
         this.query = query;
-        this.asyncResolveFns = new Set();
-        this.optionsToIgnoreOnce = new (canUseWeakSet ? WeakSet : Set)();
         this.ssrDisabledResult = maybeDeepFreeze({
             loading: true,
             data: void 0,
@@ -6761,20 +6956,30 @@ var InternalState = (function () {
     InternalState.prototype.forceUpdate = function () {
         __DEV__ && tsInvariant.invariant.warn("Calling default no-op implementation of InternalState#forceUpdate");
     };
-    InternalState.prototype.asyncUpdate = function (signal) {
+    InternalState.prototype.executeQuery = function (options) {
         var _this = this;
-        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(watchQueryOptions);
-            signal.addEventListener('abort', handleAborted);
-            _this.forceUpdate();
+        var _a;
+        if (options.query) {
+            Object.assign(this, { query: options.query });
+        }
+        this.watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options);
+        var concast = this.observable.reobserveAsConcast(this.getObsQueryOptions());
+        this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
+        this.result = void 0;
+        this.forceUpdate();
+        return new Promise(function (resolve) {
+            var result;
+            concast.subscribe({
+                next: function (value) {
+                    result = value;
+                },
+                error: function () {
+                    resolve(_this.toQueryResult(_this.observable.getCurrentResult()));
+                },
+                complete: function () {
+                    resolve(_this.toQueryResult(result));
+                }
+            });
         });
     };
     InternalState.prototype.useQuery = function (options) {
@@ -6792,7 +6997,7 @@ var InternalState = (function () {
                 if (previousResult &&
                     previousResult.loading === result.loading &&
                     previousResult.networkStatus === result.networkStatus &&
-                    equality.equal(previousResult.data, result.data)) {
+                    equal.equal(previousResult.data, result.data)) {
                     return;
                 }
                 _this.setResult(result);
@@ -6813,7 +7018,7 @@ var InternalState = (function () {
                 var previousResult = _this.result;
                 if (!previousResult ||
                     (previousResult && previousResult.loading) ||
-                    !equality.equal(error, previousResult.error)) {
+                    !equal.equal(error, previousResult.error)) {
                     _this.setResult({
                         data: (previousResult && previousResult.data),
                         error: error,
@@ -6830,22 +7035,15 @@ var InternalState = (function () {
             this.client.disableNetworkFetches,
         ]), function () { return _this.getCurrentResult(); }, function () { return _this.getCurrentResult(); });
         this.unsafeHandlePartialRefetch(result);
-        var queryResult = this.toQueryResult(result);
-        if (!queryResult.loading && this.asyncResolveFns.size) {
-            this.asyncResolveFns.forEach(function (resolve) { return resolve(queryResult); });
-            this.asyncResolveFns.clear();
-        }
-        return queryResult;
+        return this.toQueryResult(result);
     };
     InternalState.prototype.useOptions = function (options) {
         var _a;
         var watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options);
         var currentWatchQueryOptions = this.watchQueryOptions;
-        if (this.optionsToIgnoreOnce.has(currentWatchQueryOptions) ||
-            !equality.equal(watchQueryOptions, currentWatchQueryOptions)) {
+        if (!equal.equal(watchQueryOptions, currentWatchQueryOptions)) {
             this.watchQueryOptions = watchQueryOptions;
             if (currentWatchQueryOptions && this.observable) {
-                this.optionsToIgnoreOnce.delete(currentWatchQueryOptions);
                 this.observable.reobserve(this.getObsQueryOptions());
                 this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
                 this.result = void 0;
@@ -7012,11 +7210,15 @@ var EAGER_METHODS = [
     'subscribeToMore',
 ];
 function useLazyQuery(query, options) {
-    var _a, _b;
-    var abortControllersRef = React.useRef(new Set());
+    var _a;
     var execOptionsRef = React.useRef();
-    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 optionsRef = React.useRef();
+    var queryRef = React.useRef();
+    var merged = mergeOptions(options, execOptionsRef.current || {});
+    var document = (_a = merged === null || merged === void 0 ? void 0 : merged.query) !== null && _a !== void 0 ? _a : query;
+    optionsRef.current = merged;
+    queryRef.current = document;
+    var internalState = useInternalState(useApolloClient(options && options.client), document);
     var useQueryResult = internalState.useQuery(tslib.__assign(tslib.__assign({}, merged), { skip: !execOptionsRef.current }));
     var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||
         internalState.getDefaultFetchPolicy();
@@ -7042,28 +7244,15 @@ 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 options = mergeOptions(optionsRef.current, tslib.__assign({ query: queryRef.current }, execOptionsRef.current));
         var promise = internalState
-            .asyncUpdate(controller.signal)
-            .then(function (queryResult) {
-            abortControllersRef.current.delete(controller);
-            return Object.assign(queryResult, eagerMethods);
-        });
-        promise.catch(function () {
-            abortControllersRef.current.delete(controller);
-        });
+            .executeQuery(tslib.__assign(tslib.__assign({}, options), { skip: false }))
+            .then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
+        promise.catch(function () { });
         return promise;
     }, []);
     return [execute, result];
@@ -7119,7 +7308,7 @@ function useMutation(mutation, options) {
                     error: error,
                     client: client,
                 };
-                if (ref.current.isMounted && !equality.equal(ref.current.result, result_1)) {
+                if (ref.current.isMounted && !equal.equal(ref.current.result, result_1)) {
                     setResult(ref.current.result = result_1);
                 }
             }
@@ -7137,7 +7326,7 @@ function useMutation(mutation, options) {
                     called: true,
                     client: client,
                 };
-                if (!equality.equal(ref.current.result, result_2)) {
+                if (!equal.equal(ref.current.result, result_2)) {
                     setResult(ref.current.result = result_2);
                 }
             }
@@ -7227,7 +7416,7 @@ function useSubscription(subscription, options) {
                 subscription !== ref.current.subscription ||
                 (options === null || options === void 0 ? void 0 : options.fetchPolicy) !== ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||
                 !(options === null || options === void 0 ? void 0 : options.skip) !== !((_c = ref.current.options) === null || _c === void 0 ? void 0 : _c.skip) ||
-                !equality.equal(options === null || options === void 0 ? void 0 : options.variables, (_d = ref.current.options) === null || _d === void 0 ? void 0 : _d.variables))) ||
+                !equal.equal(options === null || options === void 0 ? void 0 : options.variables, (_d = ref.current.options) === null || _d === void 0 ? void 0 : _d.variables))) ||
             canResetObservableRef.current) {
             setResult({
                 loading: true,
@@ -7323,13 +7512,13 @@ function useFragment_experimental(options) {
     var getSnapshot = function () {
         var latestDiffToResult = diffToResult(latestDiff);
         return resultRef.current &&
-            equality.equal(resultRef.current.data, latestDiffToResult.data)
+            equal.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)) {
+                if (!equal.equal(diff, latestDiff)) {
                     resultRef.current = diffToResult((latestDiff = diff));
                     forceUpdate();
                 }
@@ -7349,7 +7538,7 @@ function diffToResult(diff) {
 
 function useDeepMemo(memoFn, deps) {
     var ref = React.useRef();
-    if (!ref.current || !equality.equal(ref.current.deps, deps)) {
+    if (!ref.current || !equal.equal(ref.current.deps, deps)) {
         ref.current = { value: memoFn(), deps: deps };
     }
     return ref.current.value;
@@ -7365,42 +7554,20 @@ function useStrictModeSafeCleanupEffect(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;
+var useKey = 'use';
+var realHook = React__default[useKey];
+var __use = realHook ||
+    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 (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());
@@ -7418,15 +7585,18 @@ function useSuspenseQuery_experimental(query, options) {
     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 _b = options.suspensePolicy, suspensePolicy = _b === void 0 ? 'always' : _b, _c = options.queryKey, queryKey = _c === void 0 ? [] : _c;
     var shouldSuspend = suspensePolicy === 'always' || !didPreviouslySuspend.current;
-    var subscription = suspenseCache.getSubscription(client, query, variables, function () { return client.watchQuery(watchQueryOptions); });
+    var cacheKey = [client, query, canonicalStringify(variables)].concat(queryKey);
+    var subscription = suspenseCache.getSubscription(cacheKey, 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 (!equal.equal(variables, previousVariables.current)) {
         if (result.networkStatus !== exports.NetworkStatus.ready) {
             result = tslib.__assign(tslib.__assign({}, result), { data: previousData.current, networkStatus: exports.NetworkStatus.setVariables });
         }
@@ -7604,16 +7774,16 @@ var SuspenseCache = (function () {
         this.subscriptions = new Map();
         this.options = options;
     }
-    SuspenseCache.prototype.getSubscription = function (client, query, variables, createObservable) {
+    SuspenseCache.prototype.getSubscription = function (cacheKey, 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(), {
+        var stableCacheKey = this.cacheKeys.lookupArray(cacheKey);
+        if (!this.subscriptions.has(stableCacheKey)) {
+            this.subscriptions.set(stableCacheKey, new QuerySubscription(createObservable(), {
                 autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs,
-                onDispose: function () { return _this.subscriptions.delete(cacheKey); },
+                onDispose: function () { return _this.subscriptions.delete(stableCacheKey); },
             }));
         }
-        return this.subscriptions.get(cacheKey);
+        return this.subscriptions.get(stableCacheKey);
     };
     return SuspenseCache;
 }());
@@ -7650,6 +7820,7 @@ exports.fromError = fromError;
 exports.fromPromise = fromPromise;
 exports.getApolloContext = getApolloContext;
 exports.isApolloError = isApolloError;
+exports.isNetworkRequestSettled = isNetworkRequestSettled;
 exports.isReference = isReference;
 exports.makeReference = makeReference;
 exports.makeVar = makeVar;