@apollo/client 3.4.5 → 3.4.9

package/apollo-client.cjs.js

@@ -2,17 +2,32 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var tslib = require('tslib');
 var tsInvariant = require('ts-invariant');
+var equality = require('@wry/equality');
 var process$1 = require('ts-invariant/process');
 var graphql = require('graphql');
-var tslib = require('tslib');
-var equality = require('@wry/equality');
 var zenObservableTs = require('zen-observable-ts');
 require('symbol-observable');
 var optimism = require('optimism');
 var context = require('@wry/context');
 var trie = require('@wry/trie');
 var graphqlTag = require('graphql-tag');
+var React = require('react');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            n[k] = e[k];
+        });
+    }
+    n['default'] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
 function maybe(thunk) {
     try {
@@ -50,6 +65,9 @@ function removeTemporaryGlobals() {
     return process$1.remove();
 }
 
+function checkDEV() {
+    __DEV__ ? tsInvariant.invariant("boolean" === typeof DEV, DEV) : tsInvariant.invariant("boolean" === typeof DEV, 38);
+}
 removeTemporaryGlobals();
 
 function shouldInclude(_a, variables) {
@@ -62,7 +80,7 @@ function shouldInclude(_a, variables) {
         var evaledValue = false;
         if (ifArgument.value.kind === 'Variable') {
             evaledValue = variables && variables[ifArgument.value.name.value];
-            __DEV__ ? tsInvariant.invariant(evaledValue !== void 0, "Invalid variable referenced in @" + directive.name.value + " directive.") : tsInvariant.invariant(evaledValue !== void 0, 43);
+            __DEV__ ? tsInvariant.invariant(evaledValue !== void 0, "Invalid variable referenced in @" + directive.name.value + " directive.") : tsInvariant.invariant(evaledValue !== void 0, 39);
         }
         else {
             evaledValue = ifArgument.value.value;
@@ -99,13 +117,13 @@ function getInclusionDirectives(directives) {
                 return;
             var directiveArguments = directive.arguments;
             var directiveName = directive.name.value;
-            __DEV__ ? tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, "Incorrect number of arguments for the @" + directiveName + " directive.") : tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, 44);
+            __DEV__ ? tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, "Incorrect number of arguments for the @" + directiveName + " directive.") : tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, 40);
             var ifArgument = directiveArguments[0];
-            __DEV__ ? tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', "Invalid argument for the @" + directiveName + " directive.") : tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', 45);
+            __DEV__ ? tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', "Invalid argument for the @" + directiveName + " directive.") : tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', 41);
             var ifValue = ifArgument.value;
             __DEV__ ? tsInvariant.invariant(ifValue &&
                 (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), "Argument for the @" + directiveName + " directive must be a variable or a boolean value.") : tsInvariant.invariant(ifValue &&
-                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 46);
+                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 42);
             result.push({ directive: directive, ifArgument: ifArgument });
         });
     }
@@ -118,14 +136,14 @@ function getFragmentQueryDocument(document, fragmentName) {
     document.definitions.forEach(function (definition) {
         if (definition.kind === 'OperationDefinition') {
             throw __DEV__ ? new tsInvariant.InvariantError("Found a " + definition.operation + " operation" + (definition.name ? " named '" + definition.name.value + "'" : '') + ". " +
-                'No operations are allowed when using a fragment as a query. Only fragments are allowed.') : new tsInvariant.InvariantError(47);
+                'No operations are allowed when using a fragment as a query. Only fragments are allowed.') : new tsInvariant.InvariantError(43);
         }
         if (definition.kind === 'FragmentDefinition') {
             fragments.push(definition);
         }
     });
     if (typeof actualFragmentName === 'undefined') {
-        __DEV__ ? tsInvariant.invariant(fragments.length === 1, "Found " + fragments.length + " fragments. `fragmentName` must be provided when there is not exactly 1 fragment.") : tsInvariant.invariant(fragments.length === 1, 48);
+        __DEV__ ? tsInvariant.invariant(fragments.length === 1, "Found " + fragments.length + " fragments. `fragmentName` must be provided when there is not exactly 1 fragment.") : tsInvariant.invariant(fragments.length === 1, 44);
         actualFragmentName = fragments[0].name.value;
     }
     var query = tslib.__assign(tslib.__assign({}, document), { definitions: tslib.__spreadArray([
@@ -162,7 +180,7 @@ function getFragmentFromSelection(selection, fragmentMap) {
             return selection;
         case 'FragmentSpread': {
             var fragment = fragmentMap && fragmentMap[selection.name.value];
-            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named " + selection.name.value + ".") : tsInvariant.invariant(fragment, 49);
+            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named " + selection.name.value + ".") : tsInvariant.invariant(fragment, 45);
             return fragment;
         }
         default:
@@ -246,7 +264,7 @@ function valueToObjectRepresentation(argObj, name, value, variables) {
     else {
         throw __DEV__ ? new tsInvariant.InvariantError("The inline argument \"" + name.value + "\" of kind \"" + value.kind + "\"" +
             'is not supported. Use variables instead of inline arguments to ' +
-            'overcome this limitation.') : new tsInvariant.InvariantError(58);
+            'overcome this limitation.') : new tsInvariant.InvariantError(54);
     }
 }
 function storeKeyNameFromField(field, variables) {
@@ -380,16 +398,16 @@ function isInlineFragment(selection) {
 }
 
 function checkDocument(doc) {
-    __DEV__ ? tsInvariant.invariant(doc && doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc && doc.kind === 'Document', 50);
+    __DEV__ ? tsInvariant.invariant(doc && doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc && doc.kind === 'Document', 46);
     var operations = doc.definitions
         .filter(function (d) { return d.kind !== 'FragmentDefinition'; })
         .map(function (definition) {
         if (definition.kind !== 'OperationDefinition') {
-            throw __DEV__ ? new tsInvariant.InvariantError("Schema type definitions not allowed in queries. Found: \"" + definition.kind + "\"") : new tsInvariant.InvariantError(51);
+            throw __DEV__ ? new tsInvariant.InvariantError("Schema type definitions not allowed in queries. Found: \"" + definition.kind + "\"") : new tsInvariant.InvariantError(47);
         }
         return definition;
     });
-    __DEV__ ? tsInvariant.invariant(operations.length <= 1, "Ambiguous GraphQL document: contains " + operations.length + " operations") : tsInvariant.invariant(operations.length <= 1, 52);
+    __DEV__ ? tsInvariant.invariant(operations.length <= 1, "Ambiguous GraphQL document: contains " + operations.length + " operations") : tsInvariant.invariant(operations.length <= 1, 48);
     return doc;
 }
 function getOperationDefinition(doc) {
@@ -408,14 +426,14 @@ function getFragmentDefinitions(doc) {
 }
 function getQueryDefinition(doc) {
     var queryDef = getOperationDefinition(doc);
-    __DEV__ ? tsInvariant.invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.') : tsInvariant.invariant(queryDef && queryDef.operation === 'query', 53);
+    __DEV__ ? tsInvariant.invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.') : tsInvariant.invariant(queryDef && queryDef.operation === 'query', 49);
     return queryDef;
 }
 function getFragmentDefinition(doc) {
-    __DEV__ ? tsInvariant.invariant(doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc.kind === 'Document', 54);
-    __DEV__ ? tsInvariant.invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.') : tsInvariant.invariant(doc.definitions.length <= 1, 55);
+    __DEV__ ? tsInvariant.invariant(doc.kind === 'Document', "Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql") : tsInvariant.invariant(doc.kind === 'Document', 50);
+    __DEV__ ? tsInvariant.invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.') : tsInvariant.invariant(doc.definitions.length <= 1, 51);
     var fragmentDef = doc.definitions[0];
-    __DEV__ ? tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.') : tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 56);
+    __DEV__ ? tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.') : tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 52);
     return fragmentDef;
 }
 function getMainDefinition(queryDoc) {
@@ -438,7 +456,7 @@ function getMainDefinition(queryDoc) {
     if (fragmentDefinition) {
         return fragmentDefinition;
     }
-    throw __DEV__ ? new tsInvariant.InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.') : new tsInvariant.InvariantError(57);
+    throw __DEV__ ? new tsInvariant.InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.') : new tsInvariant.InvariantError(53);
 }
 function getDefaultValues(definition) {
     var defaultValues = Object.create(null);
@@ -937,7 +955,7 @@ var Concast = (function (_super) {
                 var sub = _this.sub;
                 if (sub !== null) {
                     if (sub)
-                        Promise.resolve().then(function () { return sub.unsubscribe(); });
+                        setTimeout(function () { return sub.unsubscribe(); });
                     _this.sub = null;
                     _this.latest = ["error", error];
                     _this.reject(error);
@@ -1086,7 +1104,7 @@ function stringifyForDisplay(value) {
     }).split(JSON.stringify(undefId)).join("<undefined>");
 }
 
-__DEV__ ? tsInvariant.invariant("boolean" === typeof DEV, DEV) : tsInvariant.invariant("boolean" === typeof DEV, 59);
+checkDEV();
 
 function fromError(errorValue) {
     return new zenObservableTs.Observable(function (observer) {
@@ -1143,7 +1161,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: " + key) : new tsInvariant.InvariantError(29);
+            throw __DEV__ ? new tsInvariant.InvariantError("illegal argument: " + key) : new tsInvariant.InvariantError(26);
         }
     }
     return operation;
@@ -1266,7 +1284,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(23);
+        throw __DEV__ ? new tsInvariant.InvariantError('request is not implemented') : new tsInvariant.InvariantError(21);
     };
     ApolloLink.prototype.onError = function (error, observer) {
         if (observer && observer.error) {
@@ -1292,7 +1310,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.4.5';
+var version = '3.4.9';
 
 var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
 function parseAndCheckHttpResponse(operations) {
@@ -1332,7 +1350,7 @@ var serializeFetchParameter = function (p, label) {
         serialized = JSON.stringify(p);
     }
     catch (e) {
-        var parseError = __DEV__ ? new tsInvariant.InvariantError("Network request failed. " + label + " is not serializable: " + e.message) : new tsInvariant.InvariantError(26);
+        var parseError = __DEV__ ? new tsInvariant.InvariantError("Network request failed. " + label + " is not serializable: " + e.message) : new tsInvariant.InvariantError(23);
         parseError.parseError = e;
         throw parseError;
     }
@@ -1392,7 +1410,7 @@ function headersToLowerCase(headers) {
 
 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(25);
+        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);
     }
 };
 
@@ -1460,12 +1478,12 @@ function rewriteURIForGET(chosenURI, body) {
     return { newURI: newURI };
 }
 
+var backupFetch = maybe(function () { return fetch; });
 var createHttpLink = function (linkOptions) {
     if (linkOptions === void 0) { linkOptions = {}; }
-    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, fetcher = linkOptions.fetch, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, _b = linkOptions.includeUnusedVariables, includeUnusedVariables = _b === void 0 ? false : _b, requestOptions = tslib.__rest(linkOptions, ["uri", "fetch", "includeExtensions", "useGETForQueries", "includeUnusedVariables"]);
-    checkFetcher(fetcher);
-    if (!fetcher) {
-        fetcher = fetch;
+    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, preferredFetch = linkOptions.fetch, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, _b = linkOptions.includeUnusedVariables, includeUnusedVariables = _b === void 0 ? false : _b, requestOptions = tslib.__rest(linkOptions, ["uri", "fetch", "includeExtensions", "useGETForQueries", "includeUnusedVariables"]);
+    if (__DEV__) {
+        checkFetcher(preferredFetch || backupFetch);
     }
     var linkConfig = {
         http: { includeExtensions: includeExtensions },
@@ -1540,7 +1558,8 @@ var createHttpLink = function (linkOptions) {
             }
         }
         return new zenObservableTs.Observable(function (observer) {
-            fetcher(chosenURI, options)
+            var currentFetch = preferredFetch || maybe(function () { return fetch; }) || backupFetch;
+            currentFetch(chosenURI, options)
                 .then(function (response) {
                 operation.setContext({ response: response });
                 return response;
@@ -1771,7 +1790,7 @@ var EntityStore = (function () {
             : newer;
         if (!incoming)
             return;
-        __DEV__ ? tsInvariant.invariant(typeof dataId === "string", "store.merge expects a string ID") : tsInvariant.invariant(typeof dataId === "string", 2);
+        __DEV__ ? tsInvariant.invariant(typeof dataId === "string", "store.merge expects a string ID") : tsInvariant.invariant(typeof dataId === "string", 1);
         var merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);
         this.data[dataId] = merged;
         if (merged !== existing) {
@@ -2362,7 +2381,7 @@ var StoreReader = (function () {
             !context.store.has(objectOrReference.__ref)) {
             return {
                 result: this.canon.empty,
-                missing: [missingFromInvariant(__DEV__ ? new tsInvariant.InvariantError("Dangling reference to missing " + objectOrReference.__ref + " object") : new tsInvariant.InvariantError(6), context)],
+                missing: [missingFromInvariant(__DEV__ ? new tsInvariant.InvariantError("Dangling reference to missing " + objectOrReference.__ref + " object") : new tsInvariant.InvariantError(5), context)],
             };
         }
         var variables = context.variables, policies = context.policies, store = context.store;
@@ -2401,7 +2420,7 @@ var StoreReader = (function () {
                     if (!addTypenameToDocument.added(selection)) {
                         getMissing().push(missingFromInvariant(__DEV__ ? new tsInvariant.InvariantError("Can't find field '" + selection.name.value + "' on " + (isReference(objectOrReference)
                             ? objectOrReference.__ref + " object"
-                            : "object " + JSON.stringify(objectOrReference, null, 2))) : new tsInvariant.InvariantError(7), context));
+                            : "object " + JSON.stringify(objectOrReference, null, 2))) : new tsInvariant.InvariantError(6), context));
                     }
                 }
                 else if (Array.isArray(fieldValue)) {
@@ -2498,7 +2517,7 @@ function assertSelectionSetForIdValue(store, field, fieldValue) {
         var workSet_1 = new Set([fieldValue]);
         workSet_1.forEach(function (value) {
             if (isNonNullObject(value)) {
-                __DEV__ ? tsInvariant.invariant(!isReference(value), "Missing selection set for object of type " + getTypenameFromStoreObject(store, value) + " returned for query field " + field.name.value) : tsInvariant.invariant(!isReference(value), 8);
+                __DEV__ ? tsInvariant.invariant(!isReference(value), "Missing selection set for object of type " + getTypenameFromStoreObject(store, value) + " returned for query field " + field.name.value) : tsInvariant.invariant(!isReference(value), 7);
                 Object.values(value).forEach(workSet_1.add, workSet_1);
             }
         });
@@ -2537,12 +2556,12 @@ var StoreWriter = (function () {
             context: context,
         });
         if (!isReference(ref)) {
-            throw __DEV__ ? new tsInvariant.InvariantError("Could not identify object " + JSON.stringify(result)) : new tsInvariant.InvariantError(9);
+            throw __DEV__ ? new tsInvariant.InvariantError("Could not identify object " + JSON.stringify(result)) : new tsInvariant.InvariantError(8);
         }
         context.incomingById.forEach(function (_a, dataId) {
             var fields = _a.fields, mergeTree = _a.mergeTree, selections = _a.selections;
             var entityRef = makeReference(dataId);
-            if (mergeTree.map.size) {
+            if (mergeTree && mergeTree.map.size) {
                 var applied = _this.applyMerges(mergeTree, entityRef, fields, context);
                 if (isReference(applied)) {
                     return;
@@ -2560,7 +2579,7 @@ var StoreWriter = (function () {
                     }
                 });
                 var hasMergeFunction_1 = function (storeFieldName) {
-                    var childTree = mergeTree.map.get(storeFieldName);
+                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);
                     return Boolean(childTree && childTree.info && childTree.info.merge);
                 };
                 Object.keys(fields).forEach(function (storeFieldName) {
@@ -2669,7 +2688,7 @@ var StoreWriter = (function () {
             else {
                 context.incomingById.set(dataId, {
                     fields: incomingFields,
-                    mergeTree: mergeTree,
+                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
                     selections: selections,
                 });
             }
@@ -3034,7 +3053,7 @@ var Policies = (function () {
         var rootId = "ROOT_" + which.toUpperCase();
         var old = this.rootTypenamesById[rootId];
         if (typename !== old) {
-            __DEV__ ? tsInvariant.invariant(!old || old === which, "Cannot change root " + which + " __typename more than once") : tsInvariant.invariant(!old || old === which, 3);
+            __DEV__ ? tsInvariant.invariant(!old || old === which, "Cannot change root " + which + " __typename more than once") : tsInvariant.invariant(!old || old === which, 2);
             if (old)
                 delete this.rootIdsByTypename[old];
             this.rootIdsByTypename[typename] = rootId;
@@ -3278,7 +3297,7 @@ function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, contex
 function makeMergeObjectsFunction(store) {
     return function mergeObjects(existing, incoming) {
         if (Array.isArray(existing) || Array.isArray(incoming)) {
-            throw __DEV__ ? new tsInvariant.InvariantError("Cannot automatically merge arrays") : new tsInvariant.InvariantError(4);
+            throw __DEV__ ? new tsInvariant.InvariantError("Cannot automatically merge arrays") : new tsInvariant.InvariantError(3);
         }
         if (isNonNullObject(existing) &&
             isNonNullObject(incoming)) {
@@ -3359,24 +3378,27 @@ function makeAliasMap(selectionSet, fragmentMap) {
 }
 function computeKeyObject(response, specifier, strict, aliasMap) {
     var keyObj = Object.create(null);
-    var prevKey;
+    var lastResponseKey;
+    var lastActualKey;
     specifier.forEach(function (s) {
         if (Array.isArray(s)) {
-            if (typeof prevKey === "string") {
+            if (typeof lastActualKey === "string" &&
+                typeof lastResponseKey === "string") {
                 var subsets = aliasMap && aliasMap.subsets;
-                var subset = subsets && subsets[prevKey];
-                keyObj[prevKey] = computeKeyObject(response[prevKey], s, strict, subset);
+                var subset = subsets && subsets[lastActualKey];
+                keyObj[lastActualKey] =
+                    computeKeyObject(response[lastResponseKey], s, strict, subset);
             }
         }
         else {
             var aliases = aliasMap && aliasMap.aliases;
             var responseName = aliases && aliases[s] || s;
             if (hasOwn.call(response, responseName)) {
-                keyObj[prevKey = s] = response[responseName];
+                keyObj[lastActualKey = s] = response[lastResponseKey = responseName];
             }
             else {
-                __DEV__ ? tsInvariant.invariant(!strict, "Missing field '" + responseName + "' while computing key fields") : tsInvariant.invariant(!strict, 5);
-                prevKey = void 0;
+                __DEV__ ? tsInvariant.invariant(!strict, "Missing field '" + responseName + "' while computing key fields") : tsInvariant.invariant(!strict, 4);
+                lastResponseKey = lastActualKey = void 0;
             }
         }
     });
@@ -3668,7 +3690,7 @@ var InMemoryCache = (function (_super) {
     return InMemoryCache;
 }(ApolloCache));
 
-__DEV__ ? tsInvariant.invariant("boolean" === typeof DEV, DEV) : tsInvariant.invariant("boolean" === typeof DEV, 22);
+checkDEV();
 function isApolloError(err) {
     return err.hasOwnProperty('graphQLErrors');
 }
@@ -3735,11 +3757,12 @@ var ObservableQuery = (function (_super) {
             catch (_a) { }
             var first = !_this.observers.size;
             _this.observers.add(observer);
-            if (_this.lastError) {
-                observer.error && observer.error(_this.lastError);
+            var last = _this.last;
+            if (last && last.error) {
+                observer.error && observer.error(last.error);
             }
-            else if (_this.lastResult) {
-                observer.next && observer.next(_this.lastResult);
+            else if (last && last.result) {
+                observer.next && observer.next(last.result);
             }
             if (first) {
                 _this.reobserve().catch(function () { });
@@ -3752,18 +3775,6 @@ var ObservableQuery = (function (_super) {
         }) || this;
         _this.observers = new Set();
         _this.subscriptions = new Set();
-        _this.observer = {
-            next: function (result) {
-                if (_this.lastError || _this.isDifferentFromLastResult(result)) {
-                    _this.updateLastResult(result);
-                    iterateObserversSafely(_this.observers, 'next', result);
-                }
-            },
-            error: function (error) {
-                _this.updateLastResult(tslib.__assign(tslib.__assign({}, _this.lastResult), { error: error, errors: error.graphQLErrors, networkStatus: exports.NetworkStatus.error, loading: false }));
-                iterateObserversSafely(_this.observers, 'error', _this.lastError = error);
-            },
-        };
         _this.isTornDown = false;
         _this.options = options;
         _this.queryId = queryInfo.queryId || queryManager.generateQueryId();
@@ -3802,15 +3813,20 @@ var ObservableQuery = (function (_super) {
     };
     ObservableQuery.prototype.getCurrentResult = function (saveAsLastResult) {
         if (saveAsLastResult === void 0) { saveAsLastResult = true; }
-        var _a = this, lastResult = _a.lastResult, _b = _a.options.fetchPolicy, fetchPolicy = _b === void 0 ? "cache-first" : _b;
+        var lastResult = this.getLastResult(true);
         var networkStatus = this.queryInfo.networkStatus ||
             (lastResult && lastResult.networkStatus) ||
             exports.NetworkStatus.ready;
         var result = tslib.__assign(tslib.__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });
         if (!this.queryManager.transform(this.options.query).hasForcedResolvers) {
             var diff = this.queryInfo.getDiff();
-            result.data = (diff.complete ||
-                this.options.returnPartialData) ? diff.result : void 0;
+            if (diff.complete || this.options.returnPartialData) {
+                result.data = diff.result;
+            }
+            if (equality.equal(result.data, {})) {
+                result.data = void 0;
+            }
+            var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a;
             if (diff.complete) {
                 if (result.networkStatus === exports.NetworkStatus.loading &&
                     (fetchPolicy === 'cache-first' ||
@@ -3823,12 +3839,13 @@ var ObservableQuery = (function (_super) {
             else if (fetchPolicy !== "no-cache") {
                 result.partial = true;
             }
-            if (!diff.complete &&
+            if (__DEV__ &&
+                !diff.complete &&
                 !this.options.partialRefetch &&
                 !result.loading &&
                 !result.data &&
                 !result.error) {
-                result.error = new ApolloError({ clientErrors: diff.missing });
+                logMissingFieldErrors(diff.missing);
             }
         }
         if (saveAsLastResult) {
@@ -3837,18 +3854,24 @@ var ObservableQuery = (function (_super) {
         return result;
     };
     ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {
-        return !equality.equal(this.lastResultSnapshot, newResult);
+        return !this.last || !equality.equal(this.last.result, newResult);
     };
-    ObservableQuery.prototype.getLastResult = function () {
-        return this.lastResult;
+    ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {
+        var last = this.last;
+        if (last &&
+            last[key] &&
+            (!variablesMustMatch || equality.equal(last.variables, this.variables))) {
+            return last[key];
+        }
+    };
+    ObservableQuery.prototype.getLastResult = function (variablesMustMatch) {
+        return this.getLast("result", variablesMustMatch);
     };
-    ObservableQuery.prototype.getLastError = function () {
-        return this.lastError;
+    ObservableQuery.prototype.getLastError = function (variablesMustMatch) {
+        return this.getLast("error", variablesMustMatch);
     };
     ObservableQuery.prototype.resetLastResults = function () {
-        delete this.lastResult;
-        delete this.lastResultSnapshot;
-        delete this.lastError;
+        delete this.last;
         this.isTornDown = false;
     };
     ObservableQuery.prototype.resetQueryStoreErrors = function () {
@@ -3961,12 +3984,10 @@ var ObservableQuery = (function (_super) {
         }, exports.NetworkStatus.setVariables);
     };
     ObservableQuery.prototype.updateQuery = function (mapFn) {
-        var _a;
         var queryManager = this.queryManager;
         var result = queryManager.cache.diff({
             query: this.options.query,
             variables: this.variables,
-            previousResult: (_a = this.lastResult) === null || _a === void 0 ? void 0 : _a.data,
             returnPartialData: true,
             optimistic: false,
         }).result;
@@ -4011,7 +4032,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, 13);
+        __DEV__ ? tsInvariant.invariant(pollInterval, 'Attempted to start a polling query without a polling interval.') : tsInvariant.invariant(pollInterval, 12);
         var info = pollingInfo || (this.pollingInfo = {});
         info.interval = pollInterval;
         var maybeFetch = function () {
@@ -4035,18 +4056,18 @@ var ObservableQuery = (function (_super) {
         };
         poll();
     };
-    ObservableQuery.prototype.updateLastResult = function (newResult) {
-        var previousResult = this.lastResult;
-        this.lastResult = newResult;
-        this.lastResultSnapshot = this.queryManager.assumeImmutableResults
-            ? newResult
-            : cloneDeep(newResult);
+    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.lastError;
+            delete this.last.error;
         }
-        return previousResult;
+        return this.last;
     };
     ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
+        var _this = this;
         this.isTornDown = false;
         var useDisposableConcast = newNetworkStatus === exports.NetworkStatus.refetch ||
             newNetworkStatus === exports.NetworkStatus.fetchMore ||
@@ -4067,18 +4088,39 @@ var ObservableQuery = (function (_super) {
                 }
             }
         }
+        var variables = options.variables && tslib.__assign({}, options.variables);
         var concast = this.fetch(options, newNetworkStatus);
+        var observer = {
+            next: function (result) {
+                _this.reportResult(result, variables);
+            },
+            error: function (error) {
+                _this.reportError(error, variables);
+            },
+        };
         if (!useDisposableConcast) {
-            if (this.concast) {
+            if (this.concast && this.observer) {
                 this.concast.removeObserver(this.observer, true);
             }
             this.concast = concast;
+            this.observer = observer;
         }
-        concast.addObserver(this.observer);
+        concast.addObserver(observer);
         return concast.promise;
     };
     ObservableQuery.prototype.observe = function () {
-        this.observer.next(this.getCurrentResult(false));
+        this.reportResult(this.getCurrentResult(false), this.variables);
+    };
+    ObservableQuery.prototype.reportResult = function (result, variables) {
+        if (this.getLastError() || this.isDifferentFromLastResult(result)) {
+            this.updateLastResult(result, variables);
+            iterateObserversSafely(this.observers, 'next', result);
+        }
+    };
+    ObservableQuery.prototype.reportError = function (error, variables) {
+        var errorResult = tslib.__assign(tslib.__assign({}, this.getLastResult()), { error: error, errors: error.graphQLErrors, networkStatus: exports.NetworkStatus.error, loading: false });
+        this.updateLastResult(errorResult, variables);
+        iterateObserversSafely(this.observers, 'error', this.last.error = error);
     };
     ObservableQuery.prototype.hasObservers = function () {
         return this.observers.size > 0;
@@ -4086,9 +4128,10 @@ var ObservableQuery = (function (_super) {
     ObservableQuery.prototype.tearDownQuery = function () {
         if (this.isTornDown)
             return;
-        if (this.concast) {
+        if (this.concast && this.observer) {
             this.concast.removeObserver(this.observer);
             delete this.concast;
+            delete this.observer;
         }
         this.stopPolling();
         this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });
@@ -4103,6 +4146,11 @@ fixObservableSubclass(ObservableQuery);
 function defaultSubscriptionObserverErrorCallback(error) {
     __DEV__ && tsInvariant.invariant.error('Unhandled error', error.message, error.stack);
 }
+function logMissingFieldErrors(missing) {
+    if (__DEV__ && isNonEmptyArray(missing)) {
+        __DEV__ && tsInvariant.invariant.debug("Missing cache result fields: " + missing.map(function (m) { return m.path.join('.'); }).join(', '), missing);
+    }
+}
 function applyNextFetchPolicy(options) {
     var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a, nextFetchPolicy = options.nextFetchPolicy;
     if (nextFetchPolicy) {
@@ -4281,7 +4329,7 @@ var LocalState = (function () {
                         }
                         else {
                             fragment = fragmentMap[selection.name.value];
-                            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named " + selection.name.value) : tsInvariant.invariant(fragment, 12);
+                            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named " + selection.name.value) : tsInvariant.invariant(fragment, 11);
                         }
                         if (fragment && fragment.typeCondition) {
                             typeCondition = fragment.typeCondition.name.value;
@@ -4667,29 +4715,31 @@ 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(14));
+        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('QueryManager stopped while query was in flight') : new tsInvariant.InvariantError(13));
     };
     QueryManager.prototype.cancelPendingFetches = function (error) {
         this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });
         this.fetchCancelFns.clear();
     };
     QueryManager.prototype.mutate = function (_a) {
-        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueries = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, onQueryUpdated = _a.onQueryUpdated, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, keepRootFields = _a.keepRootFields, context = _a.context;
+        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueries = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, onQueryUpdated = _a.onQueryUpdated, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, _e = _a.fetchPolicy, fetchPolicy = _e === void 0 ? 'network-only' : _e, keepRootFields = _a.keepRootFields, context = _a.context;
         return tslib.__awaiter(this, void 0, void 0, function () {
             var mutationId, mutationStoreValue, self;
-            return tslib.__generator(this, function (_e) {
-                switch (_e.label) {
+            return tslib.__generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
-                        __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 || fetchPolicy === 'no-cache', "Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.") : tsInvariant.invariant(!fetchPolicy || fetchPolicy === 'no-cache', 16);
+                        __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(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);
                         mutationId = this.generateMutationId();
                         mutation = this.transform(mutation).document;
                         variables = this.getVariables(mutation, variables);
                         if (!this.transform(mutation).hasClientExports) return [3, 2];
                         return [4, this.localState.addExportedVariables(mutation, variables, context)];
                     case 1:
-                        variables = (_e.sent());
-                        _e.label = 2;
+                        variables = (_f.sent());
+                        _f.label = 2;
                     case 2:
                         mutationStoreValue = this.mutationStore &&
                             (this.mutationStore[mutationId] = {
@@ -4966,10 +5016,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, 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);
+            '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);
         return this.fetchQuery(queryId, options).finally(function () { return _this.stopQuery(queryId); });
     };
     QueryManager.prototype.generateQueryId = function () {
@@ -4991,7 +5041,7 @@ var QueryManager = (function () {
             queryInfo.stop();
     };
     QueryManager.prototype.clearStore = function () {
-        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('Store reset while query was in flight (not completed in link chain)') : new tsInvariant.InvariantError(21));
+        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('Store reset while query was in flight (not completed in link chain)') : new tsInvariant.InvariantError(20));
         this.queries.forEach(function (queryInfo) {
             if (queryInfo.observableQuery) {
                 queryInfo.networkStatus = exports.NetworkStatus.loading;
@@ -5266,7 +5316,7 @@ var QueryManager = (function () {
             return _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
         };
         this.fetchCancelFns.set(queryId, function (reason) {
-            Promise.resolve().then(function () { return concast.cancel(reason); });
+            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)
@@ -5359,10 +5409,9 @@ var QueryManager = (function () {
             if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || exports.NetworkStatus.loading; }
             var data = diff.result;
             if (__DEV__ &&
-                isNonEmptyArray(diff.missing) &&
-                !equality.equal(data, {}) &&
-                !returnPartialData) {
-                __DEV__ && tsInvariant.invariant.debug("Missing cache result fields: " + diff.missing.map(function (m) { return m.path.join('.'); }).join(', '), diff.missing);
+                !returnPartialData &&
+                !equality.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 }))); };
             if (data && _this.transform(query).hasForcedResolvers) {
@@ -5485,7 +5534,7 @@ var ApolloClient = (function () {
         if (!cache) {
             throw __DEV__ ? new tsInvariant.InvariantError("To initialize Apollo Client, you must specify a 'cache' property " +
                 "in the options object. \n" +
-                "For more information, please visit: https://go.apollo.dev/c/docs") : new tsInvariant.InvariantError(10);
+                "For more information, please visit: https://go.apollo.dev/c/docs") : new tsInvariant.InvariantError(9);
         }
         this.link = link;
         this.cache = cache;
@@ -5581,7 +5630,7 @@ var ApolloClient = (function () {
         __DEV__ ? tsInvariant.invariant(options.fetchPolicy !== 'cache-and-network', 'The cache-and-network fetchPolicy does not work with client.query, because ' +
             'client.query can only return a single result. Please use client.watchQuery ' +
             'to receive multiple results from the cache and the network, or consider ' +
-            'using a different fetchPolicy, such as cache-first or network-only.') : tsInvariant.invariant(options.fetchPolicy !== 'cache-and-network', 11);
+            'using a different fetchPolicy, such as cache-first or network-only.') : tsInvariant.invariant(options.fetchPolicy !== 'cache-and-network', 10);
         if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {
             options = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: 'cache-first' });
         }
@@ -5692,7 +5741,842 @@ var ApolloClient = (function () {
     return ApolloClient;
 }());
 
-tsInvariant.setVerbosity(DEV ? "log" : "silent");
+var cache$1 = new (canUseWeakMap ? WeakMap : Map)();
+function getApolloContext() {
+    var context = cache$1.get(React__namespace.createContext);
+    if (!context) {
+        context = React__namespace.createContext({});
+        context.displayName = 'ApolloContext';
+        cache$1.set(React__namespace.createContext, context);
+    }
+    return context;
+}
+
+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);
+        return props.children(context.client);
+    });
+};
+
+var ApolloProvider = function (_a) {
+    var client = _a.client, children = _a.children;
+    var ApolloContext = getApolloContext();
+    return React__namespace.createElement(ApolloContext.Consumer, null, function (context) {
+        if (context === void 0) { context = {}; }
+        if (client && context.client !== client) {
+            context = Object.assign({}, context, { client: client });
+        }
+        __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);
+        return (React__namespace.createElement(ApolloContext.Provider, { value: context }, children));
+    });
+};
+
+function useApolloClient() {
+    var client = React__namespace.useContext(getApolloContext()).client;
+    __DEV__ ? tsInvariant.invariant(client, 'No Apollo Client instance can be found. Please ensure that you ' +
+        'have called `ApolloProvider` higher up in your tree.') : tsInvariant.invariant(client, 33);
+    return client;
+}
+
+checkDEV();
+exports.DocumentType = void 0;
+(function (DocumentType) {
+    DocumentType[DocumentType["Query"] = 0] = "Query";
+    DocumentType[DocumentType["Mutation"] = 1] = "Mutation";
+    DocumentType[DocumentType["Subscription"] = 2] = "Subscription";
+})(exports.DocumentType || (exports.DocumentType = {}));
+var cache = new Map();
+function operationName(type) {
+    var name;
+    switch (type) {
+        case exports.DocumentType.Query:
+            name = 'Query';
+            break;
+        case exports.DocumentType.Mutation:
+            name = 'Mutation';
+            break;
+        case exports.DocumentType.Subscription:
+            name = 'Subscription';
+            break;
+    }
+    return name;
+}
+function parser(document) {
+    var cached = cache.get(document);
+    if (cached)
+        return cached;
+    var variables, type, name;
+    __DEV__ ? tsInvariant.invariant(!!document && !!document.kind, "Argument of " + 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);
+    var fragments = document.definitions.filter(function (x) { return x.kind === 'FragmentDefinition'; });
+    var queries = document.definitions.filter(function (x) {
+        return x.kind === 'OperationDefinition' && x.operation === 'query';
+    });
+    var mutations = document.definitions.filter(function (x) {
+        return x.kind === 'OperationDefinition' && x.operation === 'mutation';
+    });
+    var subscriptions = document.definitions.filter(function (x) {
+        return x.kind === 'OperationDefinition' && x.operation === 'subscription';
+    });
+    __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);
+    __DEV__ ? tsInvariant.invariant(queries.length + mutations.length + subscriptions.length <= 1, "react-apollo only supports a query, subscription, or a mutation per HOC. " +
+        (document + " had " + queries.length + " queries, " + subscriptions.length + " ") +
+        ("subscriptions and " + 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);
+    type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;
+    if (!queries.length && !mutations.length)
+        type = exports.DocumentType.Subscription;
+    var definitions = queries.length
+        ? queries
+        : mutations.length
+            ? mutations
+            : subscriptions;
+    __DEV__ ? tsInvariant.invariant(definitions.length === 1, "react-apollo only supports one definition per HOC. " + document + " had " +
+        (definitions.length + " definitions. ") +
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(definitions.length === 1, 37);
+    var definition = definitions[0];
+    variables = definition.variableDefinitions || [];
+    if (definition.name && definition.name.kind === 'Name') {
+        name = definition.name.value;
+    }
+    else {
+        name = 'data';
+    }
+    var payload = { name: name, type: type, variables: variables };
+    cache.set(document, payload);
+    return payload;
+}
+
+var OperationData = (function () {
+    function OperationData(options, context) {
+        this.isMounted = false;
+        this.previousOptions = {};
+        this.context = {};
+        this.options = {};
+        this.options = options || {};
+        this.context = context || {};
+    }
+    OperationData.prototype.getOptions = function () {
+        return this.options;
+    };
+    OperationData.prototype.setOptions = function (newOptions, storePrevious) {
+        if (storePrevious === void 0) { storePrevious = false; }
+        if (storePrevious && !equality.equal(this.options, newOptions)) {
+            this.previousOptions = this.options;
+        }
+        this.options = newOptions;
+    };
+    OperationData.prototype.unmount = function () {
+        this.isMounted = false;
+    };
+    OperationData.prototype.refreshClient = function () {
+        var client = (this.options && this.options.client) ||
+            (this.context && this.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, 29);
+        var isNew = false;
+        if (client !== this.client) {
+            isNew = true;
+            this.client = client;
+            this.cleanup();
+        }
+        return {
+            client: this.client,
+            isNew: isNew
+        };
+    };
+    OperationData.prototype.verifyDocumentType = function (document, type) {
+        var operation = parser(document);
+        var requiredOperationName = operationName(type);
+        var usedOperationName = operationName(operation.type);
+        __DEV__ ? tsInvariant.invariant(operation.type === type, "Running a " + requiredOperationName + " requires a graphql " +
+            (requiredOperationName + ", but a " + usedOperationName + " was used instead.")) : tsInvariant.invariant(operation.type === type, 30);
+    };
+    return OperationData;
+}());
+
+var SubscriptionData = (function (_super) {
+    tslib.__extends(SubscriptionData, _super);
+    function SubscriptionData(_a) {
+        var options = _a.options, context = _a.context, setResult = _a.setResult;
+        var _this = _super.call(this, options, context) || this;
+        _this.currentObservable = {};
+        _this.setResult = setResult;
+        _this.initialize(options);
+        return _this;
+    }
+    SubscriptionData.prototype.execute = function (result) {
+        if (this.getOptions().skip === true) {
+            this.cleanup();
+            return {
+                loading: false,
+                error: undefined,
+                data: undefined,
+                variables: this.getOptions().variables
+            };
+        }
+        var currentResult = result;
+        if (this.refreshClient().isNew) {
+            currentResult = this.getLoadingResult();
+        }
+        var shouldResubscribe = this.getOptions().shouldResubscribe;
+        if (typeof shouldResubscribe === 'function') {
+            shouldResubscribe = !!shouldResubscribe(this.getOptions());
+        }
+        if (shouldResubscribe !== false &&
+            this.previousOptions &&
+            Object.keys(this.previousOptions).length > 0 &&
+            (this.previousOptions.subscription !== this.getOptions().subscription ||
+                !equality.equal(this.previousOptions.variables, this.getOptions().variables) ||
+                this.previousOptions.skip !== this.getOptions().skip)) {
+            this.cleanup();
+            currentResult = this.getLoadingResult();
+        }
+        this.initialize(this.getOptions());
+        this.startSubscription();
+        this.previousOptions = this.getOptions();
+        return tslib.__assign(tslib.__assign({}, currentResult), { variables: this.getOptions().variables });
+    };
+    SubscriptionData.prototype.afterExecute = function () {
+        this.isMounted = true;
+    };
+    SubscriptionData.prototype.cleanup = function () {
+        this.endSubscription();
+        delete this.currentObservable.query;
+    };
+    SubscriptionData.prototype.initialize = function (options) {
+        if (this.currentObservable.query || this.getOptions().skip === true)
+            return;
+        this.currentObservable.query = this.refreshClient().client.subscribe({
+            query: options.subscription,
+            variables: options.variables,
+            fetchPolicy: options.fetchPolicy,
+            context: options.context,
+        });
+    };
+    SubscriptionData.prototype.startSubscription = function () {
+        if (this.currentObservable.subscription)
+            return;
+        this.currentObservable.subscription = this.currentObservable.query.subscribe({
+            next: this.updateCurrentData.bind(this),
+            error: this.updateError.bind(this),
+            complete: this.completeSubscription.bind(this)
+        });
+    };
+    SubscriptionData.prototype.getLoadingResult = function () {
+        return {
+            loading: true,
+            error: undefined,
+            data: undefined
+        };
+    };
+    SubscriptionData.prototype.updateResult = function (result) {
+        if (this.isMounted) {
+            this.setResult(result);
+        }
+    };
+    SubscriptionData.prototype.updateCurrentData = function (result) {
+        var onSubscriptionData = this.getOptions().onSubscriptionData;
+        this.updateResult({
+            data: result.data,
+            loading: false,
+            error: undefined
+        });
+        if (onSubscriptionData) {
+            onSubscriptionData({
+                client: this.refreshClient().client,
+                subscriptionData: result
+            });
+        }
+    };
+    SubscriptionData.prototype.updateError = function (error) {
+        this.updateResult({
+            error: error,
+            loading: false
+        });
+    };
+    SubscriptionData.prototype.completeSubscription = function () {
+        var _this = this;
+        Promise.resolve().then(function () {
+            var onSubscriptionComplete = _this.getOptions().onSubscriptionComplete;
+            if (onSubscriptionComplete)
+                onSubscriptionComplete();
+            _this.endSubscription();
+        });
+    };
+    SubscriptionData.prototype.endSubscription = function () {
+        if (this.currentObservable.subscription) {
+            this.currentObservable.subscription.unsubscribe();
+            delete this.currentObservable.subscription;
+        }
+    };
+    return SubscriptionData;
+}(OperationData));
+
+var MutationData = (function (_super) {
+    tslib.__extends(MutationData, _super);
+    function MutationData(_a) {
+        var options = _a.options, context = _a.context, result = _a.result, setResult = _a.setResult;
+        var _this = _super.call(this, options, context) || this;
+        _this.runMutation = function (mutationFunctionOptions) {
+            if (mutationFunctionOptions === void 0) { mutationFunctionOptions = {}; }
+            _this.onMutationStart();
+            var mutationId = _this.generateNewMutationId();
+            return _this.mutate(mutationFunctionOptions)
+                .then(function (response) {
+                _this.onMutationCompleted(response, mutationId);
+                return response;
+            })
+                .catch(function (error) {
+                var onError = _this.getOptions().onError;
+                _this.onMutationError(error, mutationId);
+                if (onError) {
+                    onError(error);
+                    return {
+                        data: undefined,
+                        errors: error,
+                    };
+                }
+                else {
+                    throw error;
+                }
+            });
+        };
+        _this.verifyDocumentType(options.mutation, exports.DocumentType.Mutation);
+        _this.result = result;
+        _this.setResult = setResult;
+        _this.mostRecentMutationId = 0;
+        return _this;
+    }
+    MutationData.prototype.execute = function (result) {
+        this.isMounted = true;
+        this.verifyDocumentType(this.getOptions().mutation, exports.DocumentType.Mutation);
+        return [
+            this.runMutation,
+            tslib.__assign(tslib.__assign({}, result), { client: this.refreshClient().client })
+        ];
+    };
+    MutationData.prototype.afterExecute = function () {
+        this.isMounted = true;
+        return this.unmount.bind(this);
+    };
+    MutationData.prototype.cleanup = function () {
+    };
+    MutationData.prototype.mutate = function (options) {
+        return this.refreshClient().client.mutate(mergeOptions(this.getOptions(), options));
+    };
+    MutationData.prototype.onMutationStart = function () {
+        if (!this.result.loading && !this.getOptions().ignoreResults) {
+            this.updateResult({
+                loading: true,
+                error: undefined,
+                data: undefined,
+                called: true
+            });
+        }
+    };
+    MutationData.prototype.onMutationCompleted = function (response, mutationId) {
+        var _a = this.getOptions(), onCompleted = _a.onCompleted, ignoreResults = _a.ignoreResults;
+        var data = response.data, errors = response.errors;
+        var error = errors && errors.length > 0
+            ? new ApolloError({ graphQLErrors: errors })
+            : undefined;
+        var callOncomplete = function () {
+            return onCompleted ? onCompleted(data) : null;
+        };
+        if (this.isMostRecentMutation(mutationId) && !ignoreResults) {
+            this.updateResult({
+                called: true,
+                loading: false,
+                data: data,
+                error: error
+            });
+        }
+        callOncomplete();
+    };
+    MutationData.prototype.onMutationError = function (error, mutationId) {
+        if (this.isMostRecentMutation(mutationId)) {
+            this.updateResult({
+                loading: false,
+                error: error,
+                data: undefined,
+                called: true
+            });
+        }
+    };
+    MutationData.prototype.generateNewMutationId = function () {
+        return ++this.mostRecentMutationId;
+    };
+    MutationData.prototype.isMostRecentMutation = function (mutationId) {
+        return this.mostRecentMutationId === mutationId;
+    };
+    MutationData.prototype.updateResult = function (result) {
+        if (this.isMounted &&
+            (!this.previousResult || !equality.equal(this.previousResult, result))) {
+            this.setResult(result);
+            this.previousResult = result;
+            return result;
+        }
+    };
+    return MutationData;
+}(OperationData));
+
+var QueryData = (function (_super) {
+    tslib.__extends(QueryData, _super);
+    function QueryData(_a) {
+        var options = _a.options, context = _a.context, onNewData = _a.onNewData;
+        var _this = _super.call(this, options, context) || this;
+        _this.runLazy = false;
+        _this.previous = Object.create(null);
+        _this.runLazyQuery = function (options) {
+            _this.cleanup();
+            _this.runLazy = true;
+            _this.lazyOptions = options;
+            _this.onNewData();
+        };
+        _this.obsRefetch = function (variables) { var _a; return (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.refetch(variables); };
+        _this.obsFetchMore = function (fetchMoreOptions) { var _a; return (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.fetchMore(fetchMoreOptions); };
+        _this.obsUpdateQuery = function (mapFn) { var _a; return (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.updateQuery(mapFn); };
+        _this.obsStartPolling = function (pollInterval) {
+            var _a;
+            (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.startPolling(pollInterval);
+        };
+        _this.obsStopPolling = function () {
+            var _a;
+            (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.stopPolling();
+        };
+        _this.obsSubscribeToMore = function (options) { var _a; return (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.subscribeToMore(options); };
+        _this.onNewData = onNewData;
+        return _this;
+    }
+    QueryData.prototype.execute = function () {
+        this.refreshClient();
+        var _a = this.getOptions(), skip = _a.skip, query = _a.query;
+        if (skip || query !== this.previous.query) {
+            this.removeQuerySubscription();
+            this.removeObservable(!skip);
+            this.previous.query = query;
+        }
+        this.updateObservableQuery();
+        return this.getExecuteSsrResult() || this.getExecuteResult();
+    };
+    QueryData.prototype.executeLazy = function () {
+        return !this.runLazy
+            ? [
+                this.runLazyQuery,
+                {
+                    loading: false,
+                    networkStatus: exports.NetworkStatus.ready,
+                    called: false,
+                    data: undefined
+                }
+            ]
+            : [this.runLazyQuery, this.execute()];
+    };
+    QueryData.prototype.fetchData = function () {
+        var _this = this;
+        var options = this.getOptions();
+        if (options.skip || options.ssr === false)
+            return false;
+        return new Promise(function (resolve) { return _this.startQuerySubscription(resolve); });
+    };
+    QueryData.prototype.afterExecute = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.lazy, lazy = _c === void 0 ? false : _c;
+        this.isMounted = true;
+        var options = this.getOptions();
+        if (this.currentObservable &&
+            !this.ssrInitiated() &&
+            !this.client.disableNetworkFetches) {
+            this.startQuerySubscription();
+        }
+        if (!lazy || this.runLazy) {
+            this.handleErrorOrCompleted();
+        }
+        this.previousOptions = options;
+        return this.unmount.bind(this);
+    };
+    QueryData.prototype.cleanup = function () {
+        this.removeQuerySubscription();
+        this.removeObservable(true);
+        delete this.previous.result;
+    };
+    QueryData.prototype.getOptions = function () {
+        var options = _super.prototype.getOptions.call(this);
+        if (this.lazyOptions) {
+            options.variables = tslib.__assign(tslib.__assign({}, options.variables), this.lazyOptions.variables);
+            options.context = tslib.__assign(tslib.__assign({}, options.context), this.lazyOptions.context);
+        }
+        if (this.runLazy) {
+            delete options.skip;
+        }
+        return options;
+    };
+    QueryData.prototype.ssrInitiated = function () {
+        return this.context && this.context.renderPromises;
+    };
+    QueryData.prototype.getExecuteSsrResult = function () {
+        var _a = this.getOptions(), ssr = _a.ssr, skip = _a.skip;
+        var ssrDisabled = ssr === false;
+        var fetchDisabled = this.refreshClient().client.disableNetworkFetches;
+        var ssrLoading = tslib.__assign({ loading: true, networkStatus: exports.NetworkStatus.loading, called: true, data: undefined, stale: false, client: this.client }, this.observableQueryFields());
+        if (ssrDisabled && (this.ssrInitiated() || fetchDisabled)) {
+            this.previous.result = ssrLoading;
+            return ssrLoading;
+        }
+        if (this.ssrInitiated()) {
+            var result = this.getExecuteResult() || ssrLoading;
+            if (result.loading && !skip) {
+                this.context.renderPromises.addQueryPromise(this, function () { return null; });
+            }
+            return result;
+        }
+    };
+    QueryData.prototype.prepareObservableQueryOptions = function () {
+        var options = this.getOptions();
+        this.verifyDocumentType(options.query, exports.DocumentType.Query);
+        var displayName = options.displayName || 'Query';
+        if (this.ssrInitiated() &&
+            (options.fetchPolicy === 'network-only' ||
+                options.fetchPolicy === 'cache-and-network')) {
+            options.fetchPolicy = 'cache-first';
+        }
+        return tslib.__assign(tslib.__assign({}, options), { displayName: displayName, context: options.context });
+    };
+    QueryData.prototype.initializeObservableQuery = function () {
+        if (this.ssrInitiated()) {
+            this.currentObservable = this.context.renderPromises.getSSRObservable(this.getOptions());
+        }
+        if (!this.currentObservable) {
+            var observableQueryOptions = this.prepareObservableQueryOptions();
+            this.previous.observableQueryOptions = tslib.__assign(tslib.__assign({}, observableQueryOptions), { children: void 0 });
+            this.currentObservable = this.refreshClient().client.watchQuery(tslib.__assign({}, observableQueryOptions));
+            if (this.ssrInitiated()) {
+                this.context.renderPromises.registerSSRObservable(this.currentObservable, observableQueryOptions);
+            }
+        }
+    };
+    QueryData.prototype.updateObservableQuery = function () {
+        if (!this.currentObservable) {
+            this.initializeObservableQuery();
+            return;
+        }
+        var newObservableQueryOptions = tslib.__assign(tslib.__assign({}, this.prepareObservableQueryOptions()), { children: void 0 });
+        if (this.getOptions().skip) {
+            this.previous.observableQueryOptions = newObservableQueryOptions;
+            return;
+        }
+        if (!equality.equal(newObservableQueryOptions, this.previous.observableQueryOptions)) {
+            this.previous.observableQueryOptions = newObservableQueryOptions;
+            this.currentObservable
+                .setOptions(newObservableQueryOptions)
+                .catch(function () { });
+        }
+    };
+    QueryData.prototype.startQuerySubscription = function (onNewData) {
+        var _this = this;
+        if (onNewData === void 0) { onNewData = this.onNewData; }
+        if (this.currentSubscription || this.getOptions().skip)
+            return;
+        this.currentSubscription = this.currentObservable.subscribe({
+            next: function (_a) {
+                var loading = _a.loading, networkStatus = _a.networkStatus, data = _a.data;
+                var previousResult = _this.previous.result;
+                if (previousResult &&
+                    previousResult.loading === loading &&
+                    previousResult.networkStatus === networkStatus &&
+                    equality.equal(previousResult.data, data)) {
+                    return;
+                }
+                onNewData();
+            },
+            error: function (error) {
+                _this.resubscribeToQuery();
+                if (!error.hasOwnProperty('graphQLErrors'))
+                    throw error;
+                var previousResult = _this.previous.result;
+                if ((previousResult && previousResult.loading) ||
+                    !equality.equal(error, _this.previous.error)) {
+                    _this.previous.error = error;
+                    onNewData();
+                }
+            }
+        });
+    };
+    QueryData.prototype.resubscribeToQuery = function () {
+        this.removeQuerySubscription();
+        var currentObservable = this.currentObservable;
+        if (currentObservable) {
+            var last = currentObservable["last"];
+            try {
+                currentObservable.resetLastResults();
+                this.startQuerySubscription();
+            }
+            finally {
+                currentObservable["last"] = last;
+            }
+        }
+    };
+    QueryData.prototype.getExecuteResult = function () {
+        var result = this.observableQueryFields();
+        var options = this.getOptions();
+        if (options.skip) {
+            result = tslib.__assign(tslib.__assign({}, result), { data: undefined, error: undefined, loading: false, networkStatus: exports.NetworkStatus.ready, called: true });
+        }
+        else if (this.currentObservable) {
+            var currentResult = this.currentObservable.getCurrentResult();
+            var data = currentResult.data, loading = currentResult.loading, partial = currentResult.partial, networkStatus = currentResult.networkStatus, errors = currentResult.errors;
+            var error = currentResult.error;
+            if (errors && errors.length > 0) {
+                error = new ApolloError({ graphQLErrors: errors });
+            }
+            result = tslib.__assign(tslib.__assign({}, result), { data: data, loading: loading, networkStatus: networkStatus, error: error, called: true });
+            if (loading) ;
+            else if (error) {
+                Object.assign(result, {
+                    data: (this.currentObservable.getLastResult() || {})
+                        .data
+                });
+            }
+            else {
+                var fetchPolicy = this.currentObservable.options.fetchPolicy;
+                var partialRefetch = options.partialRefetch;
+                if (partialRefetch &&
+                    partial &&
+                    (!data || Object.keys(data).length === 0) &&
+                    fetchPolicy !== 'cache-only') {
+                    Object.assign(result, {
+                        loading: true,
+                        networkStatus: exports.NetworkStatus.loading
+                    });
+                    result.refetch();
+                    return result;
+                }
+            }
+        }
+        result.client = this.client;
+        this.setOptions(options, true);
+        var previousResult = this.previous.result;
+        this.previous.loading =
+            previousResult && previousResult.loading || false;
+        result.previousData = previousResult &&
+            (previousResult.data || previousResult.previousData);
+        this.previous.result = result;
+        this.currentObservable && this.currentObservable.resetQueryStoreErrors();
+        return result;
+    };
+    QueryData.prototype.handleErrorOrCompleted = function () {
+        if (!this.currentObservable || !this.previous.result)
+            return;
+        var _a = this.previous.result, data = _a.data, loading = _a.loading, error = _a.error;
+        if (!loading) {
+            var _b = this.getOptions(), query = _b.query, variables = _b.variables, onCompleted = _b.onCompleted, onError = _b.onError, skip = _b.skip;
+            if (this.previousOptions &&
+                !this.previous.loading &&
+                equality.equal(this.previousOptions.query, query) &&
+                equality.equal(this.previousOptions.variables, variables)) {
+                return;
+            }
+            if (onCompleted && !error && !skip) {
+                onCompleted(data);
+            }
+            else if (onError && error) {
+                onError(error);
+            }
+        }
+    };
+    QueryData.prototype.removeQuerySubscription = function () {
+        if (this.currentSubscription) {
+            this.currentSubscription.unsubscribe();
+            delete this.currentSubscription;
+        }
+    };
+    QueryData.prototype.removeObservable = function (andDelete) {
+        if (this.currentObservable) {
+            this.currentObservable["tearDownQuery"]();
+            if (andDelete) {
+                delete this.currentObservable;
+            }
+        }
+    };
+    QueryData.prototype.observableQueryFields = function () {
+        var _a;
+        return {
+            variables: (_a = this.currentObservable) === null || _a === void 0 ? void 0 : _a.variables,
+            refetch: this.obsRefetch,
+            fetchMore: this.obsFetchMore,
+            updateQuery: this.obsUpdateQuery,
+            startPolling: this.obsStartPolling,
+            stopPolling: this.obsStopPolling,
+            subscribeToMore: this.obsSubscribeToMore
+        };
+    };
+    return QueryData;
+}(OperationData));
+
+function useDeepMemo(memoFn, key) {
+    var ref = React.useRef();
+    if (!ref.current || !equality.equal(key, ref.current.key)) {
+        ref.current = { key: key, value: memoFn() };
+    }
+    return ref.current.value;
+}
+
+function useAfterFastRefresh(effectFn) {
+    if (__DEV__) {
+        var didRefresh_1 = React.useRef(false);
+        React.useEffect(function () {
+            return function () {
+                didRefresh_1.current = true;
+            };
+        }, []);
+        React.useEffect(function () {
+            if (didRefresh_1.current === true) {
+                didRefresh_1.current = false;
+                effectFn();
+            }
+        }, []);
+    }
+}
+
+function useBaseQuery(query, options, lazy) {
+    if (lazy === void 0) { lazy = false; }
+    var context = React.useContext(getApolloContext());
+    var _a = React.useReducer(function (x) { return x + 1; }, 0), tick = _a[0], forceUpdate = _a[1];
+    var updatedOptions = options ? tslib.__assign(tslib.__assign({}, options), { query: query }) : { query: query };
+    var queryDataRef = React.useRef();
+    var queryData = queryDataRef.current || (queryDataRef.current = new QueryData({
+        options: updatedOptions,
+        context: context,
+        onNewData: function () {
+            if (!queryData.ssrInitiated()) {
+                Promise.resolve().then(function () { return queryDataRef.current && queryDataRef.current.isMounted && forceUpdate(); });
+            }
+            else {
+                forceUpdate();
+            }
+        }
+    }));
+    queryData.setOptions(updatedOptions);
+    queryData.context = context;
+    var memo = {
+        options: tslib.__assign(tslib.__assign({}, updatedOptions), { onError: void 0, onCompleted: void 0 }),
+        context: context,
+        tick: tick
+    };
+    var result = useDeepMemo(function () { return (lazy ? queryData.executeLazy() : queryData.execute()); }, memo);
+    var queryResult = lazy
+        ? result[1]
+        : result;
+    if (__DEV__) {
+        useAfterFastRefresh(forceUpdate);
+    }
+    React.useEffect(function () {
+        return function () {
+            queryData.cleanup();
+            queryDataRef.current = void 0;
+        };
+    }, []);
+    React.useEffect(function () { return queryData.afterExecute({ lazy: lazy }); }, [
+        queryResult.loading,
+        queryResult.networkStatus,
+        queryResult.error,
+        queryResult.data,
+        queryData.currentObservable,
+    ]);
+    return result;
+}
+
+function useLazyQuery(query, options) {
+    return useBaseQuery(query, options, true);
+}
+
+function useMutation(mutation, options) {
+    var context = React.useContext(getApolloContext());
+    var _a = React.useState({ called: false, loading: false }), result = _a[0], setResult = _a[1];
+    var updatedOptions = options ? tslib.__assign(tslib.__assign({}, options), { mutation: mutation }) : { mutation: mutation };
+    var mutationDataRef = React.useRef();
+    function getMutationDataRef() {
+        if (!mutationDataRef.current) {
+            mutationDataRef.current = new MutationData({
+                options: updatedOptions,
+                context: context,
+                result: result,
+                setResult: setResult
+            });
+        }
+        return mutationDataRef.current;
+    }
+    var mutationData = getMutationDataRef();
+    mutationData.setOptions(updatedOptions);
+    mutationData.context = context;
+    React.useEffect(function () { return mutationData.afterExecute(); });
+    return mutationData.execute(result);
+}
+
+function useQuery(query, options) {
+    return useBaseQuery(query, options, false);
+}
+
+function useSubscription(subscription, options) {
+    var _a = React.useReducer(function (x) { return x + 1; }, 0), forceUpdate = _a[1];
+    var context = React.useContext(getApolloContext());
+    var updatedOptions = options
+        ? tslib.__assign(tslib.__assign({}, options), { subscription: subscription }) : { subscription: subscription };
+    var _b = React.useState({
+        loading: !updatedOptions.skip,
+        error: void 0,
+        data: void 0,
+    }), result = _b[0], setResult = _b[1];
+    var subscriptionDataRef = React.useRef();
+    function getSubscriptionDataRef() {
+        if (!subscriptionDataRef.current) {
+            subscriptionDataRef.current = new SubscriptionData({
+                options: updatedOptions,
+                context: context,
+                setResult: setResult
+            });
+        }
+        return subscriptionDataRef.current;
+    }
+    var subscriptionData = getSubscriptionDataRef();
+    subscriptionData.setOptions(updatedOptions, true);
+    subscriptionData.context = context;
+    if (__DEV__) {
+        useAfterFastRefresh(forceUpdate);
+    }
+    React.useEffect(function () { return subscriptionData.afterExecute(); });
+    React.useEffect(function () {
+        return function () {
+            subscriptionData.cleanup();
+            subscriptionDataRef.current = void 0;
+        };
+    }, []);
+    return subscriptionData.execute(result);
+}
+
+function useReactiveVar(rv) {
+    var value = rv();
+    var setValue = React.useState(value)[1];
+    React.useEffect(function () {
+        var probablySameValue = rv();
+        if (value !== probablySameValue) {
+            setValue(probablySameValue);
+        }
+        else {
+            return rv.onNextChange(setValue);
+        }
+    }, [value]);
+    return value;
+}
 
 exports.setLogVerbosity = tsInvariant.setVerbosity;
 exports.Observable = zenObservableTs.Observable;
@@ -5703,8 +6587,10 @@ exports.gql = graphqlTag.gql;
 exports.resetCaches = graphqlTag.resetCaches;
 exports.ApolloCache = ApolloCache;
 exports.ApolloClient = ApolloClient;
+exports.ApolloConsumer = ApolloConsumer;
 exports.ApolloError = ApolloError;
 exports.ApolloLink = ApolloLink;
+exports.ApolloProvider = ApolloProvider;
 exports.HttpLink = HttpLink;
 exports.InMemoryCache = InMemoryCache;
 exports.MissingFieldError = MissingFieldError;
@@ -5721,12 +6607,16 @@ exports.fallbackHttpConfig = fallbackHttpConfig;
 exports.from = from;
 exports.fromError = fromError;
 exports.fromPromise = fromPromise;
+exports.getApolloContext = getApolloContext;
 exports.isApolloError = isApolloError;
 exports.isReference = isReference;
 exports.makeReference = makeReference;
 exports.makeVar = makeVar;
 exports.mergeOptions = mergeOptions;
+exports.operationName = operationName;
 exports.parseAndCheckHttpResponse = parseAndCheckHttpResponse;
+exports.parser = parser;
+exports.resetApolloContext = getApolloContext;
 exports.rewriteURIForGET = rewriteURIForGET;
 exports.selectHttpOptionsAndBody = selectHttpOptionsAndBody;
 exports.selectURI = selectURI;
@@ -5734,4 +6624,10 @@ exports.serializeFetchParameter = serializeFetchParameter;
 exports.split = split;
 exports.throwServerError = throwServerError;
 exports.toPromise = toPromise;
+exports.useApolloClient = useApolloClient;
+exports.useLazyQuery = useLazyQuery;
+exports.useMutation = useMutation;
+exports.useQuery = useQuery;
+exports.useReactiveVar = useReactiveVar;
+exports.useSubscription = useSubscription;
 //# sourceMappingURL=apollo-client.cjs.js.map