@apollo/client 3.4.17 → 3.5.6

package/{apollo-client.cjs.js → apollo-client.cjs}

@@ -18,11 +18,11 @@ function _interopNamespace(e) {
     if (e && e.__esModule) return e;
     var n = Object.create(null);
     if (e) {
-        Object.keys(e).forEach(function (k) {
+        for (var k in e) {
             n[k] = e[k];
-        });
+        }
     }
-    n['default'] = e;
+    n["default"] = e;
     return Object.freeze(n);
 }
 
@@ -45,7 +45,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, 39);
+            __DEV__ ? tsInvariant.invariant(evaledValue !== void 0, "Invalid variable referenced in @".concat(directive.name.value, " directive.")) : tsInvariant.invariant(evaledValue !== void 0, 37);
         }
         else {
             evaledValue = ifArgument.value.value;
@@ -82,13 +82,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, 40);
+            __DEV__ ? tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, "Incorrect number of arguments for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(directiveArguments && directiveArguments.length === 1, 38);
             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', 41);
+            __DEV__ ? tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', "Invalid argument for the @".concat(directiveName, " directive.")) : tsInvariant.invariant(ifArgument.name && ifArgument.name.value === 'if', 39);
             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'), 42);
+                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), "Argument for the @".concat(directiveName, " directive must be a variable or a boolean value.")) : tsInvariant.invariant(ifValue &&
+                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 40);
             result.push({ directive: directive, ifArgument: ifArgument });
         });
     }
@@ -100,15 +100,15 @@ function getFragmentQueryDocument(document, fragmentName) {
     var fragments = [];
     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(43);
+            throw __DEV__ ? new tsInvariant.InvariantError("Found a ".concat(definition.operation, " operation").concat(definition.name ? " named '".concat(definition.name.value, "'") : '', ". ") +
+                'No operations are allowed when using a fragment as a query. Only fragments are allowed.') : new tsInvariant.InvariantError(41);
         }
         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, 44);
+        __DEV__ ? tsInvariant.invariant(fragments.length === 1, "Found ".concat(fragments.length, " fragments. `fragmentName` must be provided when there is not exactly 1 fragment.")) : tsInvariant.invariant(fragments.length === 1, 42);
         actualFragmentName = fragments[0].name.value;
     }
     var query = tslib.__assign(tslib.__assign({}, document), { definitions: tslib.__spreadArray([
@@ -145,7 +145,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, 45);
+            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named ".concat(selection.name.value, ".")) : tsInvariant.invariant(fragment, 43);
             return fragment;
         }
         default:
@@ -227,9 +227,9 @@ function valueToObjectRepresentation(argObj, name, value, variables) {
         argObj[name.value] = null;
     }
     else {
-        throw __DEV__ ? new tsInvariant.InvariantError("The inline argument \"" + name.value + "\" of kind \"" + value.kind + "\"" +
+        throw __DEV__ ? new tsInvariant.InvariantError("The inline argument \"".concat(name.value, "\" of kind \"").concat(value.kind, "\"") +
             'is not supported. Use variables instead of inline arguments to ' +
-            'overcome this limitation.') : new tsInvariant.InvariantError(54);
+            'overcome this limitation.') : new tsInvariant.InvariantError(52);
     }
 }
 function storeKeyNameFromField(field, variables) {
@@ -279,7 +279,7 @@ var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
             filterKeys.forEach(function (key) {
                 filteredArgs_1[key] = args[key];
             });
-            return directives['connection']['key'] + "(" + stringify(filteredArgs_1) + ")";
+            return "".concat(directives['connection']['key'], "(").concat(stringify(filteredArgs_1), ")");
         }
         else {
             return directives['connection']['key'];
@@ -288,17 +288,17 @@ var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
     var completeFieldName = fieldName;
     if (args) {
         var stringifiedArgs = stringify(args);
-        completeFieldName += "(" + stringifiedArgs + ")";
+        completeFieldName += "(".concat(stringifiedArgs, ")");
     }
     if (directives) {
         Object.keys(directives).forEach(function (key) {
             if (KNOWN_DIRECTIVES.indexOf(key) !== -1)
                 return;
             if (directives[key] && Object.keys(directives[key]).length) {
-                completeFieldName += "@" + key + "(" + stringify(directives[key]) + ")";
+                completeFieldName += "@".concat(key, "(").concat(stringify(directives[key]), ")");
             }
             else {
-                completeFieldName += "@" + key;
+                completeFieldName += "@".concat(key);
             }
         });
     }
@@ -363,16 +363,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', 46);
+    __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', 44);
     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(47);
+            throw __DEV__ ? new tsInvariant.InvariantError("Schema type definitions not allowed in queries. Found: \"".concat(definition.kind, "\"")) : new tsInvariant.InvariantError(45);
         }
         return definition;
     });
-    __DEV__ ? tsInvariant.invariant(operations.length <= 1, "Ambiguous GraphQL document: contains " + operations.length + " operations") : tsInvariant.invariant(operations.length <= 1, 48);
+    __DEV__ ? tsInvariant.invariant(operations.length <= 1, "Ambiguous GraphQL document: contains ".concat(operations.length, " operations")) : tsInvariant.invariant(operations.length <= 1, 46);
     return doc;
 }
 function getOperationDefinition(doc) {
@@ -391,14 +391,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', 49);
+    __DEV__ ? tsInvariant.invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.') : tsInvariant.invariant(queryDef && queryDef.operation === 'query', 47);
     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', 50);
-    __DEV__ ? tsInvariant.invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.') : tsInvariant.invariant(doc.definitions.length <= 1, 51);
+    __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', 48);
+    __DEV__ ? tsInvariant.invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.') : tsInvariant.invariant(doc.definitions.length <= 1, 49);
     var fragmentDef = doc.definitions[0];
-    __DEV__ ? tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.') : tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 52);
+    __DEV__ ? tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.') : tsInvariant.invariant(fragmentDef.kind === 'FragmentDefinition', 50);
     return fragmentDef;
 }
 function getMainDefinition(queryDoc) {
@@ -421,7 +421,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(53);
+    throw __DEV__ ? new tsInvariant.InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.') : new tsInvariant.InvariantError(51);
 }
 function getDefaultValues(definition) {
     var defaultValues = Object.create(null);
@@ -760,7 +760,12 @@ var DeepMerger = (function () {
         return source;
     };
     DeepMerger.prototype.shallowCopyForMerge = function (value) {
-        if (isNonNullObject(value) && !this.pastCopies.has(value)) {
+        if (isNonNullObject(value)) {
+            if (this.pastCopies.has(value)) {
+                if (!Object.isFrozen(value))
+                    return value;
+                this.pastCopies.delete(value);
+            }
             if (Array.isArray(value)) {
                 value = value.slice(0);
             }
@@ -1072,7 +1077,7 @@ var prefixCounts = new Map();
 function makeUniqueId(prefix) {
     var count = prefixCounts.get(prefix) || 1;
     prefixCounts.set(prefix, count + 1);
-    return prefix + ":" + count + ":" + Math.random().toString(36).slice(2);
+    return "".concat(prefix, ":").concat(count, ":").concat(Math.random().toString(36).slice(2));
 }
 
 function stringifyForDisplay(value) {
@@ -1137,7 +1142,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(26);
+            throw __DEV__ ? new tsInvariant.InvariantError("illegal argument: ".concat(key)) : new tsInvariant.InvariantError(24);
         }
     }
     return operation;
@@ -1260,7 +1265,7 @@ var ApolloLink = (function () {
         return ApolloLink.concat(this, next);
     };
     ApolloLink.prototype.request = function (operation, forward) {
-        throw __DEV__ ? new tsInvariant.InvariantError('request is not implemented') : new tsInvariant.InvariantError(21);
+        throw __DEV__ ? new tsInvariant.InvariantError('request is not implemented') : new tsInvariant.InvariantError(19);
     };
     ApolloLink.prototype.onError = function (error, observer) {
         if (observer && observer.error) {
@@ -1286,7 +1291,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.4.17';
+var version = '3.5.6';
 
 var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 function parseAndCheckHttpResponse(operations) {
@@ -1307,14 +1312,14 @@ function parseAndCheckHttpResponse(operations) {
     })
         .then(function (result) {
         if (response.status >= 300) {
-            throwServerError(response, result, "Response not successful: Received status code " + response.status);
+            throwServerError(response, result, "Response not successful: Received status code ".concat(response.status));
         }
         if (!Array.isArray(result) &&
             !hasOwnProperty$2.call(result, 'data') &&
             !hasOwnProperty$2.call(result, 'errors')) {
-            throwServerError(response, result, "Server response was missing for query '" + (Array.isArray(operations)
+            throwServerError(response, result, "Server response was missing for query '".concat(Array.isArray(operations)
                 ? operations.map(function (op) { return op.operationName; })
-                : operations.operationName) + "'.");
+                : operations.operationName, "'."));
         }
         return result;
     }); };
@@ -1326,7 +1331,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(23);
+        var parseError = __DEV__ ? new tsInvariant.InvariantError("Network request failed. ".concat(label, " is not serializable: ").concat(e.message)) : new tsInvariant.InvariantError(21);
         parseError.parseError = e;
         throw parseError;
     }
@@ -1349,17 +1354,28 @@ var fallbackHttpConfig = {
     headers: defaultHeaders,
     options: defaultOptions,
 };
-var selectHttpOptionsAndBody = function (operation, fallbackConfig) {
+var defaultPrinter = function (ast, printer) { return printer(ast); };
+function selectHttpOptionsAndBody(operation, fallbackConfig) {
+    var configs = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        configs[_i - 2] = arguments[_i];
+    }
+    configs.unshift(fallbackConfig);
+    return selectHttpOptionsAndBodyInternal.apply(void 0, tslib.__spreadArray([operation,
+        defaultPrinter], configs, false));
+}
+function selectHttpOptionsAndBodyInternal(operation, printer) {
     var configs = [];
     for (var _i = 2; _i < arguments.length; _i++) {
         configs[_i - 2] = arguments[_i];
     }
-    var options = tslib.__assign(tslib.__assign({}, fallbackConfig.options), { headers: fallbackConfig.headers, credentials: fallbackConfig.credentials });
-    var http = fallbackConfig.http || {};
+    var options = {};
+    var http = {};
     configs.forEach(function (config) {
         options = tslib.__assign(tslib.__assign(tslib.__assign({}, options), config.options), { headers: tslib.__assign(tslib.__assign({}, options.headers), headersToLowerCase(config.headers)) });
-        if (config.credentials)
+        if (config.credentials) {
             options.credentials = config.credentials;
+        }
         http = tslib.__assign(tslib.__assign({}, http), config.http);
     });
     var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;
@@ -1367,12 +1383,12 @@ var selectHttpOptionsAndBody = function (operation, fallbackConfig) {
     if (http.includeExtensions)
         body.extensions = extensions;
     if (http.includeQuery)
-        body.query = graphql.print(query);
+        body.query = printer(query, graphql.print);
     return {
         options: options,
         body: body,
     };
-};
+}
 function headersToLowerCase(headers) {
     if (headers) {
         var normalized_1 = Object.create(null);
@@ -1386,7 +1402,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(22);
+        throw __DEV__ ? new tsInvariant.InvariantError("\n\"fetch\" has not been found globally and no fetcher has been configured. To fix this, install a fetch package (like https://www.npmjs.com/package/cross-fetch), instantiate the fetcher, and pass it into your HttpLink constructor. For example:\n\nimport fetch from 'cross-fetch';\nimport { ApolloClient, HttpLink } from '@apollo/client';\nconst client = new ApolloClient({\n  link: new HttpLink({ uri: '/graphql', fetch })\n});\n    ") : new tsInvariant.InvariantError(20);
     }
 };
 
@@ -1415,7 +1431,7 @@ var selectURI = function (operation, fallbackURI) {
 function rewriteURIForGET(chosenURI, body) {
     var queryParams = [];
     var addQueryParam = function (key, value) {
-        queryParams.push(key + "=" + encodeURIComponent(value));
+        queryParams.push("".concat(key, "=").concat(encodeURIComponent(value)));
     };
     if ('query' in body) {
         addQueryParam('query', body.query);
@@ -1457,7 +1473,7 @@ function rewriteURIForGET(chosenURI, body) {
 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, 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"]);
+    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, preferredFetch = linkOptions.fetch, _b = linkOptions.print, print = _b === void 0 ? defaultPrinter : _b, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, _c = linkOptions.includeUnusedVariables, includeUnusedVariables = _c === void 0 ? false : _c, requestOptions = tslib.__rest(linkOptions, ["uri", "fetch", "print", "includeExtensions", "useGETForQueries", "includeUnusedVariables"]);
     if (__DEV__) {
         checkFetcher(preferredFetch || backupFetch);
     }
@@ -1487,7 +1503,7 @@ var createHttpLink = function (linkOptions) {
             credentials: context.credentials,
             headers: contextHeaders,
         };
-        var _b = selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;
+        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, {
@@ -1578,9 +1594,12 @@ var ApolloCache = (function () {
         this.getFragmentDoc = optimism.wrap(getFragmentQueryDocument);
     }
     ApolloCache.prototype.batch = function (options) {
+        var _this = this;
         var optimisticId = typeof options.optimistic === "string" ? options.optimistic :
             options.optimistic === false ? null : void 0;
-        this.performTransaction(options.update, optimisticId);
+        var updateResult;
+        this.performTransaction(function () { return updateResult = options.update(_this); }, optimisticId);
+        return updateResult;
     };
     ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {
         this.performTransaction(transaction, optimisticId);
@@ -1623,6 +1642,30 @@ var ApolloCache = (function () {
             result: data,
         }));
     };
+    ApolloCache.prototype.updateQuery = function (options, update) {
+        return this.batch({
+            update: function (cache) {
+                var value = cache.readQuery(options);
+                var data = update(value);
+                if (data === void 0 || data === null)
+                    return value;
+                cache.writeQuery(tslib.__assign(tslib.__assign({}, options), { data: data }));
+                return data;
+            },
+        });
+    };
+    ApolloCache.prototype.updateFragment = function (options, update) {
+        return this.batch({
+            update: function (cache) {
+                var value = cache.readFragment(options);
+                var data = update(value);
+                if (data === void 0 || data === null)
+                    return value;
+                cache.writeFragment(tslib.__assign(tslib.__assign({}, options), { data: data }));
+                return data;
+            },
+        });
+    };
     return ApolloCache;
 }());
 
@@ -1630,19 +1673,15 @@ exports.Cache = void 0;
 (function (Cache) {
 })(exports.Cache || (exports.Cache = {}));
 
-var MissingFieldError = (function (_super) {
-    tslib.__extends(MissingFieldError, _super);
+var MissingFieldError = (function () {
     function MissingFieldError(message, path, query, variables) {
-        var _this = _super.call(this, message) || this;
-        _this.message = message;
-        _this.path = path;
-        _this.query = query;
-        _this.variables = variables;
-        _this.__proto__ = MissingFieldError.prototype;
-        return _this;
+        this.message = message;
+        this.path = path;
+        this.query = query;
+        this.variables = variables;
     }
     return MissingFieldError;
-}(Error));
+}());
 
 var hasOwn = Object.prototype.hasOwnProperty;
 function defaultDataIdFromObject(_a, context) {
@@ -1657,7 +1696,7 @@ function defaultDataIdFromObject(_a, context) {
         if (id === void 0)
             id = _id;
         if (id !== void 0) {
-            return __typename + ":" + ((typeof id === "number" ||
+            return "".concat(__typename, ":").concat((typeof id === "number" ||
                 typeof id === "string") ? id : JSON.stringify(id));
         }
     }
@@ -2283,9 +2322,6 @@ function resetCanonicalStringify() {
     stringifyCache = new (canUseWeakMap ? WeakMap : Map)();
 }
 
-function missingFromInvariant(err, context) {
-    return new MissingFieldError(err.message, context.path.slice(), context.query, context.variables);
-}
 function execSelectionSetKeyArgs(options) {
     return [
         options.selectionSet,
@@ -2347,6 +2383,7 @@ var StoreReader = (function () {
         var policies = this.config.cache.policies;
         variables = tslib.__assign(tslib.__assign({}, getDefaultValues(getQueryDefinition(query))), variables);
         var rootRef = makeReference(rootId);
+        var merger = new DeepMerger;
         var execResult = this.executeSelectionSet({
             selectionSet: getMainDefinition(query).selectionSet,
             objectOrReference: rootRef,
@@ -2359,17 +2396,22 @@ var StoreReader = (function () {
                 varString: canonicalStringify(variables),
                 canonizeResults: canonizeResults,
                 fragmentMap: createFragmentMap(getFragmentDefinitions(query)),
-                path: [],
+                merge: function (a, b) {
+                    return merger.merge(a, b);
+                },
             },
         });
-        var hasMissingFields = execResult.missing && execResult.missing.length > 0;
-        if (hasMissingFields && !returnPartialData) {
-            throw execResult.missing[0];
+        var missing;
+        if (execResult.missing) {
+            missing = [new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables)];
+            if (!returnPartialData) {
+                throw missing[0];
+            }
         }
         return {
             result: execResult.result,
-            missing: execResult.missing,
-            complete: !hasMissingFields,
+            complete: !missing,
+            missing: missing,
         };
     };
     StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {
@@ -2390,30 +2432,28 @@ 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(5), context)],
+                missing: "Dangling reference to missing ".concat(objectOrReference.__ref, " object"),
             };
         }
         var variables = context.variables, policies = context.policies, store = context.store;
-        var objectsToMerge = [];
-        var finalResult = { result: null };
         var typename = store.getFieldValue(objectOrReference, "__typename");
+        var result = {};
+        var missing;
         if (this.config.addTypename &&
             typeof typename === "string" &&
             !policies.rootIdsByTypename[typename]) {
-            objectsToMerge.push({ __typename: typename });
-        }
-        function getMissing() {
-            return finalResult.missing || (finalResult.missing = []);
+            result = { __typename: typename };
         }
-        function handleMissing(result) {
+        function handleMissing(result, resultName) {
             var _a;
-            if (result.missing)
-                (_a = getMissing()).push.apply(_a, result.missing);
+            if (result.missing) {
+                missing = context.merge(missing, (_a = {}, _a[resultName] = result.missing, _a));
+            }
             return result.result;
         }
         var workSet = new Set(selectionSet.selections);
         workSet.forEach(function (selection) {
-            var _a;
+            var _a, _b;
             if (!shouldInclude(selection, variables))
                 return;
             if (isField(selection)) {
@@ -2424,12 +2464,13 @@ var StoreReader = (function () {
                     from: objectOrReference,
                 }, context);
                 var resultName = resultKeyNameFromField(selection);
-                context.path.push(resultName);
                 if (fieldValue === void 0) {
                     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(6), context));
+                        missing = context.merge(missing, (_a = {},
+                            _a[resultName] = "Can't find field '".concat(selection.name.value, "' on ").concat(isReference(objectOrReference)
+                                ? objectOrReference.__ref + " object"
+                                : "object " + JSON.stringify(objectOrReference, null, 2)),
+                            _a));
                     }
                 }
                 else if (Array.isArray(fieldValue)) {
@@ -2438,7 +2479,7 @@ var StoreReader = (function () {
                         array: fieldValue,
                         enclosingRef: enclosingRef,
                         context: context,
-                    }));
+                    }), resultName);
                 }
                 else if (!selection.selectionSet) {
                     if (context.canonizeResults) {
@@ -2451,12 +2492,11 @@ var StoreReader = (function () {
                         objectOrReference: fieldValue,
                         enclosingRef: isReference(fieldValue) ? fieldValue : enclosingRef,
                         context: context,
-                    }));
+                    }), resultName);
                 }
                 if (fieldValue !== void 0) {
-                    objectsToMerge.push((_a = {}, _a[resultName] = fieldValue, _a));
+                    result = context.merge(result, (_b = {}, _b[resultName] = fieldValue, _b));
                 }
-                tsInvariant.invariant(context.path.pop() === resultName);
             }
             else {
                 var fragment = getFragmentFromSelection(selection, context.fragmentMap);
@@ -2465,23 +2505,24 @@ var StoreReader = (function () {
                 }
             }
         });
-        var merged = mergeDeepArray(objectsToMerge);
-        finalResult.result = context.canonizeResults
-            ? this.canon.admit(merged)
-            : maybeDeepFreeze(merged);
-        this.knownResults.set(finalResult.result, selectionSet);
-        return finalResult;
+        var finalResult = { result: result, missing: missing };
+        var frozen = context.canonizeResults
+            ? this.canon.admit(finalResult)
+            : maybeDeepFreeze(finalResult);
+        if (frozen.result) {
+            this.knownResults.set(frozen.result, selectionSet);
+        }
+        return frozen;
     };
     StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {
         var _this = this;
         var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;
         var missing;
         function handleMissing(childResult, i) {
+            var _a;
             if (childResult.missing) {
-                missing = missing || [];
-                missing.push.apply(missing, childResult.missing);
+                missing = context.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));
             }
-            tsInvariant.invariant(context.path.pop() === i);
             return childResult.result;
         }
         if (field.selectionSet) {
@@ -2491,7 +2532,6 @@ var StoreReader = (function () {
             if (item === null) {
                 return null;
             }
-            context.path.push(i);
             if (Array.isArray(item)) {
                 return handleMissing(_this.executeSubSelectedArray({
                     field: field,
@@ -2511,7 +2551,6 @@ var StoreReader = (function () {
             if (__DEV__) {
                 assertSelectionSetForIdValue(context.store, field, item);
             }
-            tsInvariant.invariant(context.path.pop() === i);
             return item;
         });
         return {
@@ -2521,401 +2560,206 @@ var StoreReader = (function () {
     };
     return StoreReader;
 }());
+function firstMissing(tree) {
+    try {
+        JSON.stringify(tree, function (_, value) {
+            if (typeof value === "string")
+                throw value;
+            return value;
+        });
+    }
+    catch (result) {
+        return result;
+    }
+}
 function assertSelectionSetForIdValue(store, field, fieldValue) {
     if (!field.selectionSet) {
         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), 7);
+                __DEV__ ? tsInvariant.invariant(!isReference(value), "Missing selection set for object of type ".concat(getTypenameFromStoreObject(store, value), " returned for query field ").concat(field.name.value)) : tsInvariant.invariant(!isReference(value), 5);
                 Object.values(value).forEach(workSet_1.add, workSet_1);
             }
         });
     }
 }
 
-var StoreWriter = (function () {
-    function StoreWriter(cache, reader) {
-        this.cache = cache;
-        this.reader = reader;
-    }
-    StoreWriter.prototype.writeToStore = function (store, _a) {
-        var _this = this;
-        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;
-        var operationDefinition = getOperationDefinition(query);
-        var merger = makeProcessedFieldsMerger();
-        variables = tslib.__assign(tslib.__assign({}, getDefaultValues(operationDefinition)), variables);
-        var context = {
-            store: store,
-            written: Object.create(null),
-            merge: function (existing, incoming) {
-                return merger.merge(existing, incoming);
-            },
-            variables: variables,
-            varString: canonicalStringify(variables),
-            fragmentMap: createFragmentMap(getFragmentDefinitions(query)),
-            overwrite: !!overwrite,
-            incomingById: new Map,
-            clientOnly: false,
-        };
-        var ref = this.processSelectionSet({
-            result: result || Object.create(null),
-            dataId: dataId,
-            selectionSet: operationDefinition.selectionSet,
-            mergeTree: { map: new Map },
-            context: context,
+var cacheSlot = new context.Slot();
+var cacheInfoMap = new WeakMap();
+function getCacheInfo(cache) {
+    var info = cacheInfoMap.get(cache);
+    if (!info) {
+        cacheInfoMap.set(cache, info = {
+            vars: new Set,
+            dep: optimism.dep(),
         });
-        if (!isReference(ref)) {
-            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 && mergeTree.map.size) {
-                var applied = _this.applyMerges(mergeTree, entityRef, fields, context);
-                if (isReference(applied)) {
-                    return;
-                }
-                fields = applied;
-            }
-            if (__DEV__ && !context.overwrite) {
-                var hasSelectionSet_1 = function (storeFieldName) {
-                    return fieldsWithSelectionSets_1.has(fieldNameFromStoreName(storeFieldName));
-                };
-                var fieldsWithSelectionSets_1 = new Set();
-                selections.forEach(function (selection) {
-                    if (isField(selection) && selection.selectionSet) {
-                        fieldsWithSelectionSets_1.add(selection.name.value);
-                    }
-                });
-                var hasMergeFunction_1 = function (storeFieldName) {
-                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);
-                    return Boolean(childTree && childTree.info && childTree.info.merge);
-                };
-                Object.keys(fields).forEach(function (storeFieldName) {
-                    if (hasSelectionSet_1(storeFieldName) &&
-                        !hasMergeFunction_1(storeFieldName)) {
-                        warnAboutDataLoss(entityRef, fields, storeFieldName, context.store);
-                    }
+    }
+    return info;
+}
+function forgetCache(cache) {
+    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });
+}
+function recallCache(cache) {
+    getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });
+}
+function makeVar(value) {
+    var caches = new Set();
+    var listeners = new Set();
+    var rv = function (newValue) {
+        if (arguments.length > 0) {
+            if (value !== newValue) {
+                value = newValue;
+                caches.forEach(function (cache) {
+                    getCacheInfo(cache).dep.dirty(rv);
+                    broadcast(cache);
                 });
-            }
-            store.merge(dataId, fields);
-        });
-        store.retain(ref.__ref);
-        return ref;
-    };
-    StoreWriter.prototype.processSelectionSet = function (_a) {
-        var _this = this;
-        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, mergeTree = _a.mergeTree;
-        var policies = this.cache.policies;
-        var _b = policies.identify(result, selectionSet, context.fragmentMap), id = _b[0], keyObject = _b[1];
-        dataId = dataId || id;
-        if ("string" === typeof dataId) {
-            var sets = context.written[dataId] || (context.written[dataId] = []);
-            var ref = makeReference(dataId);
-            if (sets.indexOf(selectionSet) >= 0)
-                return ref;
-            sets.push(selectionSet);
-            if (this.reader && this.reader.isFresh(result, ref, selectionSet, context)) {
-                return ref;
+                var oldListeners = Array.from(listeners);
+                listeners.clear();
+                oldListeners.forEach(function (listener) { return listener(value); });
             }
         }
-        var incomingFields = Object.create(null);
-        if (keyObject) {
-            incomingFields = context.merge(incomingFields, keyObject);
-        }
-        var typename = (dataId && policies.rootTypenamesById[dataId]) ||
-            getTypenameFromResult(result, selectionSet, context.fragmentMap) ||
-            (dataId && context.store.get(dataId, "__typename"));
-        if ("string" === typeof typename) {
-            incomingFields.__typename = typename;
+        else {
+            var cache = cacheSlot.getValue();
+            if (cache) {
+                attach(cache);
+                getCacheInfo(cache).dep(rv);
+            }
         }
-        var selections = new Set(selectionSet.selections);
-        selections.forEach(function (selection) {
-            var _a;
-            if (!shouldInclude(selection, context.variables))
-                return;
-            if (isField(selection)) {
-                var resultFieldKey = resultKeyNameFromField(selection);
-                var value = result[resultFieldKey];
-                var wasClientOnly = context.clientOnly;
-                context.clientOnly = wasClientOnly || !!(selection.directives &&
-                    selection.directives.some(function (d) { return d.name.value === "client"; }));
-                if (value !== void 0) {
-                    var storeFieldName = policies.getStoreFieldName({
-                        typename: typename,
-                        fieldName: selection.name.value,
-                        field: selection,
-                        variables: context.variables,
-                    });
-                    var childTree = getChildMergeTree(mergeTree, storeFieldName);
-                    var incomingValue = _this.processFieldValue(value, selection, context, childTree);
-                    var childTypename = void 0;
-                    if (selection.selectionSet) {
-                        childTypename = context.store.getFieldValue(incomingValue, "__typename");
-                        if (!childTypename && isReference(incomingValue)) {
-                            var info = context.incomingById.get(incomingValue.__ref);
-                            childTypename = info && info.fields.__typename;
-                        }
-                    }
-                    var merge = policies.getMergeFunction(typename, selection.name.value, childTypename);
-                    if (merge) {
-                        childTree.info = {
-                            field: selection,
-                            typename: typename,
-                            merge: merge,
-                        };
-                    }
-                    else {
-                        maybeRecycleChildMergeTree(mergeTree, storeFieldName);
-                    }
-                    incomingFields = context.merge(incomingFields, (_a = {},
-                        _a[storeFieldName] = incomingValue,
-                        _a));
-                }
-                else if (!context.clientOnly &&
-                    !addTypenameToDocument.added(selection)) {
-                    __DEV__ && tsInvariant.invariant.error(("Missing field '" + resultKeyNameFromField(selection) + "' while writing result " + JSON.stringify(result, null, 2)).substring(0, 1000));
+        return value;
+    };
+    rv.onNextChange = function (listener) {
+        listeners.add(listener);
+        return function () {
+            listeners.delete(listener);
+        };
+    };
+    var attach = rv.attachCache = function (cache) {
+        caches.add(cache);
+        getCacheInfo(cache).vars.add(rv);
+        return rv;
+    };
+    rv.forgetCache = function (cache) { return caches.delete(cache); };
+    return rv;
+}
+function broadcast(cache) {
+    if (cache.broadcastWatches) {
+        cache.broadcastWatches();
+    }
+}
+
+var specifierInfoCache = Object.create(null);
+function lookupSpecifierInfo(spec) {
+    var cacheKey = JSON.stringify(spec);
+    return specifierInfoCache[cacheKey] ||
+        (specifierInfoCache[cacheKey] = Object.create(null));
+}
+function keyFieldsFnFromSpecifier(specifier) {
+    var info = lookupSpecifierInfo(specifier);
+    return info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {
+        var extract = function (from, key) { return context.readField(key, from); };
+        var keyObject = context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {
+            var extracted = extractKeyPath(context.storeObject, schemaKeyPath, extract);
+            if (extracted === void 0 &&
+                object !== context.storeObject &&
+                hasOwn.call(object, schemaKeyPath[0])) {
+                extracted = extractKeyPath(object, schemaKeyPath, extractKey);
+            }
+            __DEV__ ? tsInvariant.invariant(extracted !== void 0, "Missing field '".concat(schemaKeyPath.join('.'), "' while extracting keyFields from ").concat(JSON.stringify(object))) : tsInvariant.invariant(extracted !== void 0, 2);
+            return extracted;
+        });
+        return "".concat(context.typename, ":").concat(JSON.stringify(keyObject));
+    });
+}
+function keyArgsFnFromSpecifier(specifier) {
+    var info = lookupSpecifierInfo(specifier);
+    return info.keyArgsFn || (info.keyArgsFn = function (args, _a) {
+        var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;
+        var collected = collectSpecifierPaths(specifier, function (keyPath) {
+            var firstKey = keyPath[0];
+            var firstChar = firstKey.charAt(0);
+            if (firstChar === "@") {
+                if (field && isNonEmptyArray(field.directives)) {
+                    var directiveName_1 = firstKey.slice(1);
+                    var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });
+                    var directiveArgs = d && argumentsObjectFromField(d, variables);
+                    return directiveArgs && extractKeyPath(directiveArgs, keyPath.slice(1));
                 }
-                context.clientOnly = wasClientOnly;
+                return;
             }
-            else {
-                var fragment = getFragmentFromSelection(selection, context.fragmentMap);
-                if (fragment &&
-                    policies.fragmentMatches(fragment, typename, result, context.variables)) {
-                    fragment.selectionSet.selections.forEach(selections.add, selections);
+            if (firstChar === "$") {
+                var variableName = firstKey.slice(1);
+                if (variables && hasOwn.call(variables, variableName)) {
+                    var varKeyPath = keyPath.slice(0);
+                    varKeyPath[0] = variableName;
+                    return extractKeyPath(variables, varKeyPath);
                 }
+                return;
+            }
+            if (args) {
+                return extractKeyPath(args, keyPath);
             }
         });
-        if ("string" === typeof dataId) {
-            var previous = context.incomingById.get(dataId);
-            if (previous) {
-                previous.fields = context.merge(previous.fields, incomingFields);
-                previous.mergeTree = mergeMergeTrees(previous.mergeTree, mergeTree);
-                previous.selections.forEach(selections.add, selections);
-                previous.selections = selections;
+        var suffix = JSON.stringify(collected);
+        if (args || suffix !== "{}") {
+            fieldName += ":" + suffix;
+        }
+        return fieldName;
+    });
+}
+function collectSpecifierPaths(specifier, extractor) {
+    var merger = new DeepMerger;
+    return getSpecifierPaths(specifier).reduce(function (collected, path) {
+        var _a;
+        var toMerge = extractor(path);
+        if (toMerge !== void 0) {
+            for (var i = path.length - 1; i >= 0; --i) {
+                toMerge = (_a = {}, _a[path[i]] = toMerge, _a);
+            }
+            collected = merger.merge(collected, toMerge);
+        }
+        return collected;
+    }, Object.create(null));
+}
+function getSpecifierPaths(spec) {
+    var info = lookupSpecifierInfo(spec);
+    if (!info.paths) {
+        var paths_1 = info.paths = [];
+        var currentPath_1 = [];
+        spec.forEach(function (s, i) {
+            if (Array.isArray(s)) {
+                getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });
+                currentPath_1.length = 0;
             }
             else {
-                context.incomingById.set(dataId, {
-                    fields: incomingFields,
-                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
-                    selections: selections,
-                });
+                currentPath_1.push(s);
+                if (!Array.isArray(spec[i + 1])) {
+                    paths_1.push(currentPath_1.slice(0));
+                    currentPath_1.length = 0;
+                }
             }
-            return makeReference(dataId);
-        }
-        return incomingFields;
-    };
-    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {
-        var _this = this;
-        if (!field.selectionSet || value === null) {
-            return __DEV__ ? cloneDeep(value) : value;
-        }
+        });
+    }
+    return info.paths;
+}
+function extractKey(object, key) {
+    return object[key];
+}
+function extractKeyPath(object, path, extract) {
+    extract = extract || extractKey;
+    return normalize(path.reduce(function reducer(obj, key) {
+        return Array.isArray(obj)
+            ? obj.map(function (child) { return reducer(child, key); })
+            : obj && extract(obj, key);
+    }, object));
+}
+function normalize(value) {
+    if (isNonNullObject(value)) {
         if (Array.isArray(value)) {
-            return value.map(function (item, i) {
-                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));
-                maybeRecycleChildMergeTree(mergeTree, i);
-                return value;
-            });
+            return value.map(normalize);
         }
-        return this.processSelectionSet({
-            result: value,
-            selectionSet: field.selectionSet,
-            context: context,
-            mergeTree: mergeTree,
-        });
-    };
-    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {
-        var _a;
-        var _this = this;
-        if (mergeTree.map.size && !isReference(incoming)) {
-            var e_1 = (!Array.isArray(incoming) &&
-                (isReference(existing) || storeValueIsStoreObject(existing))) ? existing : void 0;
-            var i_1 = incoming;
-            if (e_1 && !getStorageArgs) {
-                getStorageArgs = [isReference(e_1) ? e_1.__ref : e_1];
-            }
-            var changedFields_1;
-            var getValue_1 = function (from, name) {
-                return Array.isArray(from)
-                    ? (typeof name === "number" ? from[name] : void 0)
-                    : context.store.getFieldValue(from, String(name));
-            };
-            mergeTree.map.forEach(function (childTree, storeFieldName) {
-                var eVal = getValue_1(e_1, storeFieldName);
-                var iVal = getValue_1(i_1, storeFieldName);
-                if (void 0 === iVal)
-                    return;
-                if (getStorageArgs) {
-                    getStorageArgs.push(storeFieldName);
-                }
-                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
-                if (aVal !== iVal) {
-                    changedFields_1 = changedFields_1 || new Map;
-                    changedFields_1.set(storeFieldName, aVal);
-                }
-                if (getStorageArgs) {
-                    tsInvariant.invariant(getStorageArgs.pop() === storeFieldName);
-                }
-            });
-            if (changedFields_1) {
-                incoming = (Array.isArray(i_1) ? i_1.slice(0) : tslib.__assign({}, i_1));
-                changedFields_1.forEach(function (value, name) {
-                    incoming[name] = value;
-                });
-            }
-        }
-        if (mergeTree.info) {
-            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));
-        }
-        return incoming;
-    };
-    return StoreWriter;
-}());
-var emptyMergeTreePool = [];
-function getChildMergeTree(_a, name) {
-    var map = _a.map;
-    if (!map.has(name)) {
-        map.set(name, emptyMergeTreePool.pop() || { map: new Map });
-    }
-    return map.get(name);
-}
-function mergeMergeTrees(left, right) {
-    if (left === right || !right || mergeTreeIsEmpty(right))
-        return left;
-    if (!left || mergeTreeIsEmpty(left))
-        return right;
-    var info = left.info && right.info ? tslib.__assign(tslib.__assign({}, left.info), right.info) : left.info || right.info;
-    var needToMergeMaps = left.map.size && right.map.size;
-    var map = needToMergeMaps ? new Map :
-        left.map.size ? left.map : right.map;
-    var merged = { info: info, map: map };
-    if (needToMergeMaps) {
-        var remainingRightKeys_1 = new Set(right.map.keys());
-        left.map.forEach(function (leftTree, key) {
-            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));
-            remainingRightKeys_1.delete(key);
-        });
-        remainingRightKeys_1.forEach(function (key) {
-            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));
-        });
-    }
-    return merged;
-}
-function mergeTreeIsEmpty(tree) {
-    return !tree || !(tree.info || tree.map.size);
-}
-function maybeRecycleChildMergeTree(_a, name) {
-    var map = _a.map;
-    var childTree = map.get(name);
-    if (childTree && mergeTreeIsEmpty(childTree)) {
-        emptyMergeTreePool.push(childTree);
-        map.delete(name);
-    }
-}
-var warnings = new Set();
-function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
-    var getChild = function (objOrRef) {
-        var child = store.getFieldValue(objOrRef, storeFieldName);
-        return typeof child === "object" && child;
-    };
-    var existing = getChild(existingRef);
-    if (!existing)
-        return;
-    var incoming = getChild(incomingObj);
-    if (!incoming)
-        return;
-    if (isReference(existing))
-        return;
-    if (equality.equal(existing, incoming))
-        return;
-    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
-        return;
-    }
-    var parentType = store.getFieldValue(existingRef, "__typename") ||
-        store.getFieldValue(incomingObj, "__typename");
-    var fieldName = fieldNameFromStoreName(storeFieldName);
-    var typeDotName = parentType + "." + fieldName;
-    if (warnings.has(typeDotName))
-        return;
-    warnings.add(typeDotName);
-    var childTypenames = [];
-    if (!Array.isArray(existing) &&
-        !Array.isArray(incoming)) {
-        [existing, incoming].forEach(function (child) {
-            var typename = store.getFieldValue(child, "__typename");
-            if (typeof typename === "string" &&
-                !childTypenames.includes(typename)) {
-                childTypenames.push(typename);
-            }
-        });
-    }
-    __DEV__ && tsInvariant.invariant.warn("Cache data may be lost when replacing the " + fieldName + " field of a " + parentType + " object.\n\nTo address this problem (which is not a bug in Apollo Client), " + (childTypenames.length
-        ? "either ensure all objects of type " +
-            childTypenames.join(" and ") + " have an ID or a custom merge function, or "
-        : "") + "define a custom merge function for the " + typeDotName + " field, so InMemoryCache can safely merge these objects:\n\n  existing: " + JSON.stringify(existing).slice(0, 1000) + "\n  incoming: " + JSON.stringify(incoming).slice(0, 1000) + "\n\nFor more information about these options, please refer to the documentation:\n\n  * Ensuring entity objects have IDs: https://go.apollo.dev/c/generating-unique-identifiers\n  * Defining custom merge functions: https://go.apollo.dev/c/merging-non-normalized-objects\n");
-}
-
-var cacheSlot = new context.Slot();
-var cacheInfoMap = new WeakMap();
-function getCacheInfo(cache) {
-    var info = cacheInfoMap.get(cache);
-    if (!info) {
-        cacheInfoMap.set(cache, info = {
-            vars: new Set,
-            dep: optimism.dep(),
-        });
-    }
-    return info;
-}
-function forgetCache(cache) {
-    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });
-}
-function recallCache(cache) {
-    getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });
-}
-function makeVar(value) {
-    var caches = new Set();
-    var listeners = new Set();
-    var rv = function (newValue) {
-        if (arguments.length > 0) {
-            if (value !== newValue) {
-                value = newValue;
-                caches.forEach(function (cache) {
-                    getCacheInfo(cache).dep.dirty(rv);
-                    broadcast(cache);
-                });
-                var oldListeners = Array.from(listeners);
-                listeners.clear();
-                oldListeners.forEach(function (listener) { return listener(value); });
-            }
-        }
-        else {
-            var cache = cacheSlot.getValue();
-            if (cache) {
-                attach(cache);
-                getCacheInfo(cache).dep(rv);
-            }
-        }
-        return value;
-    };
-    rv.onNextChange = function (listener) {
-        listeners.add(listener);
-        return function () {
-            listeners.delete(listener);
-        };
-    };
-    var attach = rv.attachCache = function (cache) {
-        caches.add(cache);
-        getCacheInfo(cache).vars.add(rv);
-        return rv;
-    };
-    rv.forgetCache = function (cache) { return caches.delete(cache); };
-    return rv;
-}
-function broadcast(cache) {
-    if (cache.broadcastWatches) {
-        cache.broadcastWatches();
+        return collectSpecifierPaths(Object.keys(value).sort(), function (path) { return extractKeyPath(value, path); });
     }
+    return value;
 }
 
 getStoreKeyName.setStringify(canonicalStringify);
@@ -2952,18 +2796,22 @@ var Policies = (function () {
             this.addTypePolicies(config.typePolicies);
         }
     }
-    Policies.prototype.identify = function (object, selectionSet, fragmentMap) {
-        var typename = selectionSet && fragmentMap
-            ? getTypenameFromResult(object, selectionSet, fragmentMap)
-            : object.__typename;
+    Policies.prototype.identify = function (object, partialContext) {
+        var _a;
+        var policies = this;
+        var typename = partialContext && (partialContext.typename ||
+            ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename)) || object.__typename;
         if (typename === this.rootTypenamesById.ROOT_QUERY) {
             return ["ROOT_QUERY"];
         }
-        var context = {
-            typename: typename,
-            selectionSet: selectionSet,
-            fragmentMap: fragmentMap,
-        };
+        var storeObject = partialContext && partialContext.storeObject || object;
+        var context = tslib.__assign(tslib.__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: partialContext && partialContext.readField || function () {
+                var options = normalizeReadFieldOptions(arguments, storeObject);
+                return policies.readField(options, {
+                    store: policies.cache["data"],
+                    variables: options.variables,
+                });
+            } });
         var id;
         var policy = typename && this.getTypePolicy(typename);
         var keyFn = policy && policy.keyFn || this.config.dataIdFromObject;
@@ -3045,7 +2893,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, 2);
+            __DEV__ ? tsInvariant.invariant(!old || old === which, "Cannot change root ".concat(which, " __typename more than once")) : tsInvariant.invariant(!old || old === which, 3);
             if (old)
                 delete this.rootIdsByTypename[old];
             this.rootIdsByTypename[typename] = rootId;
@@ -3129,7 +2977,7 @@ var Policies = (function () {
                 if (supertypeSet.has(supertype)) {
                     if (!typenameSupertypeSet.has(supertype)) {
                         if (checkingFuzzySubtypes) {
-                            __DEV__ && tsInvariant.invariant.warn("Inferring subtype " + typename + " of supertype " + supertype);
+                            __DEV__ && tsInvariant.invariant.warn("Inferring subtype ".concat(typename, " of supertype ").concat(supertype));
                         }
                         typenameSupertypeSet.add(supertype);
                     }
@@ -3217,6 +3065,10 @@ var Policies = (function () {
         }
         return existing;
     };
+    Policies.prototype.getReadFunction = function (typename, fieldName) {
+        var policy = this.getFieldPolicy(typename, fieldName, false);
+        return policy && policy.read;
+    };
     Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {
         var policy = this.getFieldPolicy(parentTypename, fieldName, false);
         var merge = policy && policy.merge;
@@ -3257,39 +3109,39 @@ function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, contex
         storage: storage,
         cache: policies.cache,
         canRead: canRead,
-        readField: function (fieldNameOrOptions, from) {
-            var options;
-            if (typeof fieldNameOrOptions === "string") {
-                options = {
-                    fieldName: fieldNameOrOptions,
-                    from: arguments.length > 1 ? from : objectOrReference,
-                };
-            }
-            else if (isNonNullObject(fieldNameOrOptions)) {
-                options = tslib.__assign({}, fieldNameOrOptions);
-                if (!hasOwn.call(fieldNameOrOptions, "from")) {
-                    options.from = objectOrReference;
-                }
-            }
-            else {
-                __DEV__ && tsInvariant.invariant.warn("Unexpected readField arguments: " + stringifyForDisplay(Array.from(arguments)));
-                return;
-            }
-            if (__DEV__ && options.from === void 0) {
-                __DEV__ && tsInvariant.invariant.warn("Undefined 'from' passed to readField with arguments " + stringifyForDisplay(Array.from(arguments)));
-            }
-            if (void 0 === options.variables) {
-                options.variables = variables;
-            }
-            return policies.readField(options, context);
+        readField: function () {
+            return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, context), context);
         },
         mergeObjects: makeMergeObjectsFunction(context.store),
     };
 }
+function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {
+    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;
+    var options;
+    if (typeof fieldNameOrOptions === "string") {
+        options = {
+            fieldName: fieldNameOrOptions,
+            from: argc > 1 ? from : objectOrReference,
+        };
+    }
+    else {
+        options = tslib.__assign({}, fieldNameOrOptions);
+        if (!hasOwn.call(options, "from")) {
+            options.from = objectOrReference;
+        }
+    }
+    if (__DEV__ && options.from === void 0) {
+        __DEV__ && tsInvariant.invariant.warn("Undefined 'from' passed to readField with arguments ".concat(stringifyForDisplay(Array.from(readFieldArgs))));
+    }
+    if (void 0 === options.variables) {
+        options.variables = variables;
+    }
+    return options;
+}
 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(3);
+            throw __DEV__ ? new tsInvariant.InvariantError("Cannot automatically merge arrays") : new tsInvariant.InvariantError(4);
         }
         if (isNonNullObject(existing) &&
             isNonNullObject(incoming)) {
@@ -3317,84 +3169,396 @@ function makeMergeObjectsFunction(store) {
         return incoming;
     };
 }
-function keyArgsFnFromSpecifier(specifier) {
-    return function (args, context) {
-        return args ? context.fieldName + ":" + JSON.stringify(computeKeyObject(args, specifier, false)) : context.fieldName;
-    };
+
+function getContextFlavor(context, clientOnly, deferred) {
+    var key = "".concat(clientOnly).concat(deferred);
+    var flavored = context.flavors.get(key);
+    if (!flavored) {
+        context.flavors.set(key, flavored = (context.clientOnly === clientOnly &&
+            context.deferred === deferred) ? context : tslib.__assign(tslib.__assign({}, context), { clientOnly: clientOnly, deferred: deferred }));
+    }
+    return flavored;
 }
-function keyFieldsFnFromSpecifier(specifier) {
-    var trie$1 = new trie.Trie(canUseWeakMap);
-    return function (object, context) {
-        var aliasMap;
-        if (context.selectionSet && context.fragmentMap) {
-            var info = trie$1.lookupArray([
-                context.selectionSet,
-                context.fragmentMap,
-            ]);
-            aliasMap = info.aliasMap || (info.aliasMap = makeAliasMap(context.selectionSet, context.fragmentMap));
+var StoreWriter = (function () {
+    function StoreWriter(cache, reader) {
+        this.cache = cache;
+        this.reader = reader;
+    }
+    StoreWriter.prototype.writeToStore = function (store, _a) {
+        var _this = this;
+        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;
+        var operationDefinition = getOperationDefinition(query);
+        var merger = makeProcessedFieldsMerger();
+        variables = tslib.__assign(tslib.__assign({}, getDefaultValues(operationDefinition)), variables);
+        var context = {
+            store: store,
+            written: Object.create(null),
+            merge: function (existing, incoming) {
+                return merger.merge(existing, incoming);
+            },
+            variables: variables,
+            varString: canonicalStringify(variables),
+            fragmentMap: createFragmentMap(getFragmentDefinitions(query)),
+            overwrite: !!overwrite,
+            incomingById: new Map,
+            clientOnly: false,
+            deferred: false,
+            flavors: new Map,
+        };
+        var ref = this.processSelectionSet({
+            result: result || Object.create(null),
+            dataId: dataId,
+            selectionSet: operationDefinition.selectionSet,
+            mergeTree: { map: new Map },
+            context: context,
+        });
+        if (!isReference(ref)) {
+            throw __DEV__ ? new tsInvariant.InvariantError("Could not identify object ".concat(JSON.stringify(result))) : new tsInvariant.InvariantError(6);
         }
-        var keyObject = context.keyObject =
-            computeKeyObject(object, specifier, true, aliasMap);
-        return context.typename + ":" + JSON.stringify(keyObject);
+        context.incomingById.forEach(function (_a, dataId) {
+            var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;
+            var entityRef = makeReference(dataId);
+            if (mergeTree && mergeTree.map.size) {
+                var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);
+                if (isReference(applied)) {
+                    return;
+                }
+                storeObject = applied;
+            }
+            if (__DEV__ && !context.overwrite) {
+                var fieldsWithSelectionSets_1 = Object.create(null);
+                fieldNodeSet.forEach(function (field) {
+                    if (field.selectionSet) {
+                        fieldsWithSelectionSets_1[field.name.value] = true;
+                    }
+                });
+                var hasSelectionSet_1 = function (storeFieldName) {
+                    return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] === true;
+                };
+                var hasMergeFunction_1 = function (storeFieldName) {
+                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);
+                    return Boolean(childTree && childTree.info && childTree.info.merge);
+                };
+                Object.keys(storeObject).forEach(function (storeFieldName) {
+                    if (hasSelectionSet_1(storeFieldName) &&
+                        !hasMergeFunction_1(storeFieldName)) {
+                        warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);
+                    }
+                });
+            }
+            store.merge(dataId, storeObject);
+        });
+        store.retain(ref.__ref);
+        return ref;
     };
-}
-function makeAliasMap(selectionSet, fragmentMap) {
-    var map = Object.create(null);
-    var workQueue = new Set([selectionSet]);
-    workQueue.forEach(function (selectionSet) {
-        selectionSet.selections.forEach(function (selection) {
-            if (isField(selection)) {
-                if (selection.alias) {
-                    var responseKey = selection.alias.value;
-                    var storeKey = selection.name.value;
-                    if (storeKey !== responseKey) {
-                        var aliases = map.aliases || (map.aliases = Object.create(null));
-                        aliases[storeKey] = responseKey;
+    StoreWriter.prototype.processSelectionSet = function (_a) {
+        var _this = this;
+        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, mergeTree = _a.mergeTree;
+        var policies = this.cache.policies;
+        var incoming = Object.create(null);
+        var typename = (dataId && policies.rootTypenamesById[dataId]) ||
+            getTypenameFromResult(result, selectionSet, context.fragmentMap) ||
+            (dataId && context.store.get(dataId, "__typename"));
+        if ("string" === typeof typename) {
+            incoming.__typename = typename;
+        }
+        var readField = function () {
+            var options = normalizeReadFieldOptions(arguments, incoming, context.variables);
+            if (isReference(options.from)) {
+                var info = context.incomingById.get(options.from.__ref);
+                if (info) {
+                    var result_1 = policies.readField(tslib.__assign(tslib.__assign({}, options), { from: info.storeObject }), context);
+                    if (result_1 !== void 0) {
+                        return result_1;
                     }
                 }
-                if (selection.selectionSet) {
-                    var subsets = map.subsets || (map.subsets = Object.create(null));
-                    subsets[selection.name.value] =
-                        makeAliasMap(selection.selectionSet, fragmentMap);
-                }
             }
-            else {
-                var fragment = getFragmentFromSelection(selection, fragmentMap);
-                if (fragment) {
-                    workQueue.add(fragment.selectionSet);
+            return policies.readField(options, context);
+        };
+        var fieldNodeSet = new Set();
+        this.flattenFields(selectionSet, result, context, typename).forEach(function (context, field) {
+            var _a;
+            var resultFieldKey = resultKeyNameFromField(field);
+            var value = result[resultFieldKey];
+            fieldNodeSet.add(field);
+            if (value !== void 0) {
+                var storeFieldName = policies.getStoreFieldName({
+                    typename: typename,
+                    fieldName: field.name.value,
+                    field: field,
+                    variables: context.variables,
+                });
+                var childTree = getChildMergeTree(mergeTree, storeFieldName);
+                var incomingValue = _this.processFieldValue(value, field, field.selectionSet
+                    ? getContextFlavor(context, false, false)
+                    : context, childTree);
+                var childTypename = void 0;
+                if (field.selectionSet &&
+                    (isReference(incomingValue) ||
+                        storeValueIsStoreObject(incomingValue))) {
+                    childTypename = readField("__typename", incomingValue);
                 }
+                var merge = policies.getMergeFunction(typename, field.name.value, childTypename);
+                if (merge) {
+                    childTree.info = {
+                        field: field,
+                        typename: typename,
+                        merge: merge,
+                    };
+                }
+                else {
+                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);
+                }
+                incoming = context.merge(incoming, (_a = {},
+                    _a[storeFieldName] = incomingValue,
+                    _a));
+            }
+            else if (__DEV__ &&
+                !context.clientOnly &&
+                !context.deferred &&
+                !addTypenameToDocument.added(field) &&
+                !policies.getReadFunction(typename, field.name.value)) {
+                __DEV__ && tsInvariant.invariant.error("Missing field '".concat(resultKeyNameFromField(field), "' while writing result ").concat(JSON.stringify(result, null, 2)).substring(0, 1000));
             }
         });
-    });
-    return map;
-}
-function computeKeyObject(response, specifier, strict, aliasMap) {
-    var keyObj = Object.create(null);
-    var lastResponseKey;
-    var lastActualKey;
-    specifier.forEach(function (s) {
-        if (Array.isArray(s)) {
-            if (typeof lastActualKey === "string" &&
-                typeof lastResponseKey === "string") {
-                var subsets = aliasMap && aliasMap.subsets;
-                var subset = subsets && subsets[lastActualKey];
-                keyObj[lastActualKey] =
-                    computeKeyObject(response[lastResponseKey], s, strict, subset);
+        try {
+            var _b = policies.identify(result, {
+                typename: typename,
+                selectionSet: selectionSet,
+                fragmentMap: context.fragmentMap,
+                storeObject: incoming,
+                readField: readField,
+            }), id = _b[0], keyObject = _b[1];
+            dataId = dataId || id;
+            if (keyObject) {
+                incoming = context.merge(incoming, keyObject);
             }
         }
-        else {
-            var aliases = aliasMap && aliasMap.aliases;
-            var responseName = aliases && aliases[s] || s;
-            if (hasOwn.call(response, responseName)) {
-                keyObj[lastActualKey = s] = response[lastResponseKey = responseName];
+        catch (e) {
+            if (!dataId)
+                throw e;
+        }
+        if ("string" === typeof dataId) {
+            var dataRef = makeReference(dataId);
+            var sets = context.written[dataId] || (context.written[dataId] = []);
+            if (sets.indexOf(selectionSet) >= 0)
+                return dataRef;
+            sets.push(selectionSet);
+            if (this.reader && this.reader.isFresh(result, dataRef, selectionSet, context)) {
+                return dataRef;
+            }
+            var previous_1 = context.incomingById.get(dataId);
+            if (previous_1) {
+                previous_1.storeObject = context.merge(previous_1.storeObject, incoming);
+                previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);
+                fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });
             }
             else {
-                __DEV__ ? tsInvariant.invariant(!strict, "Missing field '" + responseName + "' while computing key fields") : tsInvariant.invariant(!strict, 4);
-                lastResponseKey = lastActualKey = void 0;
+                context.incomingById.set(dataId, {
+                    storeObject: incoming,
+                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
+                    fieldNodeSet: fieldNodeSet,
+                });
             }
+            return dataRef;
         }
-    });
-    return keyObj;
+        return incoming;
+    };
+    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {
+        var _this = this;
+        if (!field.selectionSet || value === null) {
+            return __DEV__ ? cloneDeep(value) : value;
+        }
+        if (Array.isArray(value)) {
+            return value.map(function (item, i) {
+                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));
+                maybeRecycleChildMergeTree(mergeTree, i);
+                return value;
+            });
+        }
+        return this.processSelectionSet({
+            result: value,
+            selectionSet: field.selectionSet,
+            context: context,
+            mergeTree: mergeTree,
+        });
+    };
+    StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {
+        if (typename === void 0) { typename = getTypenameFromResult(result, selectionSet, context.fragmentMap); }
+        var fieldMap = new Map();
+        var policies = this.cache.policies;
+        var limitingTrie = new trie.Trie(false);
+        (function flatten(selectionSet, inheritedContext) {
+            var visitedNode = limitingTrie.lookup(selectionSet, inheritedContext.clientOnly, inheritedContext.deferred);
+            if (visitedNode.visited)
+                return;
+            visitedNode.visited = true;
+            selectionSet.selections.forEach(function (selection) {
+                if (!shouldInclude(selection, context.variables))
+                    return;
+                var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;
+                if (!(clientOnly && deferred) &&
+                    isNonEmptyArray(selection.directives)) {
+                    selection.directives.forEach(function (dir) {
+                        var name = dir.name.value;
+                        if (name === "client")
+                            clientOnly = true;
+                        if (name === "defer") {
+                            var args = argumentsObjectFromField(dir, context.variables);
+                            if (!args || args.if !== false) {
+                                deferred = true;
+                            }
+                        }
+                    });
+                }
+                if (isField(selection)) {
+                    var existing = fieldMap.get(selection);
+                    if (existing) {
+                        clientOnly = clientOnly && existing.clientOnly;
+                        deferred = deferred && existing.deferred;
+                    }
+                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));
+                }
+                else {
+                    var fragment = getFragmentFromSelection(selection, context.fragmentMap);
+                    if (fragment &&
+                        policies.fragmentMatches(fragment, typename, result, context.variables)) {
+                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));
+                    }
+                }
+            });
+        })(selectionSet, context);
+        return fieldMap;
+    };
+    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {
+        var _a;
+        var _this = this;
+        if (mergeTree.map.size && !isReference(incoming)) {
+            var e_1 = (!Array.isArray(incoming) &&
+                (isReference(existing) || storeValueIsStoreObject(existing))) ? existing : void 0;
+            var i_1 = incoming;
+            if (e_1 && !getStorageArgs) {
+                getStorageArgs = [isReference(e_1) ? e_1.__ref : e_1];
+            }
+            var changedFields_1;
+            var getValue_1 = function (from, name) {
+                return Array.isArray(from)
+                    ? (typeof name === "number" ? from[name] : void 0)
+                    : context.store.getFieldValue(from, String(name));
+            };
+            mergeTree.map.forEach(function (childTree, storeFieldName) {
+                var eVal = getValue_1(e_1, storeFieldName);
+                var iVal = getValue_1(i_1, storeFieldName);
+                if (void 0 === iVal)
+                    return;
+                if (getStorageArgs) {
+                    getStorageArgs.push(storeFieldName);
+                }
+                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
+                if (aVal !== iVal) {
+                    changedFields_1 = changedFields_1 || new Map;
+                    changedFields_1.set(storeFieldName, aVal);
+                }
+                if (getStorageArgs) {
+                    tsInvariant.invariant(getStorageArgs.pop() === storeFieldName);
+                }
+            });
+            if (changedFields_1) {
+                incoming = (Array.isArray(i_1) ? i_1.slice(0) : tslib.__assign({}, i_1));
+                changedFields_1.forEach(function (value, name) {
+                    incoming[name] = value;
+                });
+            }
+        }
+        if (mergeTree.info) {
+            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));
+        }
+        return incoming;
+    };
+    return StoreWriter;
+}());
+var emptyMergeTreePool = [];
+function getChildMergeTree(_a, name) {
+    var map = _a.map;
+    if (!map.has(name)) {
+        map.set(name, emptyMergeTreePool.pop() || { map: new Map });
+    }
+    return map.get(name);
+}
+function mergeMergeTrees(left, right) {
+    if (left === right || !right || mergeTreeIsEmpty(right))
+        return left;
+    if (!left || mergeTreeIsEmpty(left))
+        return right;
+    var info = left.info && right.info ? tslib.__assign(tslib.__assign({}, left.info), right.info) : left.info || right.info;
+    var needToMergeMaps = left.map.size && right.map.size;
+    var map = needToMergeMaps ? new Map :
+        left.map.size ? left.map : right.map;
+    var merged = { info: info, map: map };
+    if (needToMergeMaps) {
+        var remainingRightKeys_1 = new Set(right.map.keys());
+        left.map.forEach(function (leftTree, key) {
+            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));
+            remainingRightKeys_1.delete(key);
+        });
+        remainingRightKeys_1.forEach(function (key) {
+            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));
+        });
+    }
+    return merged;
+}
+function mergeTreeIsEmpty(tree) {
+    return !tree || !(tree.info || tree.map.size);
+}
+function maybeRecycleChildMergeTree(_a, name) {
+    var map = _a.map;
+    var childTree = map.get(name);
+    if (childTree && mergeTreeIsEmpty(childTree)) {
+        emptyMergeTreePool.push(childTree);
+        map.delete(name);
+    }
+}
+var warnings = new Set();
+function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
+    var getChild = function (objOrRef) {
+        var child = store.getFieldValue(objOrRef, storeFieldName);
+        return typeof child === "object" && child;
+    };
+    var existing = getChild(existingRef);
+    if (!existing)
+        return;
+    var incoming = getChild(incomingObj);
+    if (!incoming)
+        return;
+    if (isReference(existing))
+        return;
+    if (equality.equal(existing, incoming))
+        return;
+    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
+        return;
+    }
+    var parentType = store.getFieldValue(existingRef, "__typename") ||
+        store.getFieldValue(incomingObj, "__typename");
+    var fieldName = fieldNameFromStoreName(storeFieldName);
+    var typeDotName = "".concat(parentType, ".").concat(fieldName);
+    if (warnings.has(typeDotName))
+        return;
+    warnings.add(typeDotName);
+    var childTypenames = [];
+    if (!Array.isArray(existing) &&
+        !Array.isArray(incoming)) {
+        [existing, incoming].forEach(function (child) {
+            var typename = store.getFieldValue(child, "__typename");
+            if (typeof typename === "string" &&
+                !childTypenames.includes(typename)) {
+                childTypenames.push(typename);
+            }
+        });
+    }
+    __DEV__ && tsInvariant.invariant.warn("Cache data may be lost when replacing the ".concat(fieldName, " field of a ").concat(parentType, " object.\n\nTo address this problem (which is not a bug in Apollo Client), ").concat(childTypenames.length
+        ? "either ensure all objects of type " +
+            childTypenames.join(" and ") + " have an ID or a custom merge function, or "
+        : "", "define a custom merge function for the ").concat(typeDotName, " field, so InMemoryCache can safely merge these objects:\n\n  existing: ").concat(JSON.stringify(existing).slice(0, 1000), "\n  incoming: ").concat(JSON.stringify(incoming).slice(0, 1000), "\n\nFor more information about these options, please refer to the documentation:\n\n  * Ensuring entity objects have IDs: https://go.apollo.dev/c/generating-unique-identifiers\n  * Defining custom merge functions: https://go.apollo.dev/c/merging-non-normalized-objects\n"));
 }
 
 var InMemoryCache = (function (_super) {
@@ -3543,8 +3707,14 @@ var InMemoryCache = (function (_super) {
         return (optimistic ? this.optimisticData : this.data).release(rootId);
     };
     InMemoryCache.prototype.identify = function (object) {
-        return isReference(object) ? object.__ref :
-            this.policies.identify(object)[0];
+        if (isReference(object))
+            return object.__ref;
+        try {
+            return this.policies.identify(object)[0];
+        }
+        catch (e) {
+            __DEV__ && tsInvariant.invariant.warn(e);
+        }
     };
     InMemoryCache.prototype.evict = function (options) {
         if (!options.id) {
@@ -3587,6 +3757,7 @@ var InMemoryCache = (function (_super) {
     InMemoryCache.prototype.batch = function (options) {
         var _this = this;
         var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;
+        var updateResult;
         var perform = function (layer) {
             var _a = _this, data = _a.data, optimisticData = _a.optimisticData;
             ++_this.txCount;
@@ -3594,7 +3765,7 @@ var InMemoryCache = (function (_super) {
                 _this.data = _this.optimisticData = layer;
             }
             try {
-                update(_this);
+                return updateResult = update(_this);
             }
             finally {
                 --_this.txCount;
@@ -3636,6 +3807,7 @@ var InMemoryCache = (function (_super) {
         else {
             this.broadcastWatches(options);
         }
+        return updateResult;
     };
     InMemoryCache.prototype.performTransaction = function (update, optimisticId) {
         return this.batch({
@@ -3693,11 +3865,11 @@ var generateErrorMessage = function (err) {
             var errorMessage = error
                 ? error.message
                 : 'Error message not found.';
-            message += errorMessage + "\n";
+            message += "".concat(errorMessage, "\n");
         });
     }
     if (err.networkError) {
-        message += err.networkError.message + "\n";
+        message += "".concat(err.networkError.message, "\n");
     }
     message = message.replace(/\n$/, '');
     return message;
@@ -3810,11 +3982,11 @@ var ObservableQuery = (function (_super) {
             exports.NetworkStatus.ready;
         var result = tslib.__assign(tslib.__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });
         var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a;
-        var shouldReturnCachedData = lastResult || (fetchPolicy !== 'network-only' &&
-            fetchPolicy !== 'no-cache' &&
-            fetchPolicy !== 'standby');
-        if (shouldReturnCachedData &&
-            !this.queryManager.transform(this.options.query).hasForcedResolvers) {
+        if (fetchPolicy === 'network-only' ||
+            fetchPolicy === 'no-cache' ||
+            fetchPolicy === 'standby' ||
+            this.queryManager.transform(this.options.query).hasForcedResolvers) ;
+        else {
             var diff = this.queryInfo.getDiff();
             if (diff.complete || this.options.returnPartialData) {
                 result.data = diff.result;
@@ -3823,15 +3995,16 @@ var ObservableQuery = (function (_super) {
                 result.data = void 0;
             }
             if (diff.complete) {
-                if (result.networkStatus === exports.NetworkStatus.loading &&
+                delete result.partial;
+                if (diff.complete &&
+                    result.networkStatus === exports.NetworkStatus.loading &&
                     (fetchPolicy === 'cache-first' ||
                         fetchPolicy === 'cache-only')) {
                     result.networkStatus = exports.NetworkStatus.ready;
                     result.loading = false;
                 }
-                delete result.partial;
             }
-            else if (fetchPolicy !== "no-cache") {
+            else {
                 result.partial = true;
             }
             if (__DEV__ &&
@@ -3878,17 +4051,20 @@ var ObservableQuery = (function (_super) {
             pollInterval: 0,
         };
         var fetchPolicy = this.options.fetchPolicy;
-        if (fetchPolicy === 'no-cache') {
+        if (fetchPolicy === 'standby' || fetchPolicy === 'cache-and-network') {
+            reobserveOptions.fetchPolicy = fetchPolicy;
+        }
+        else if (fetchPolicy === 'no-cache') {
             reobserveOptions.fetchPolicy = 'no-cache';
         }
-        else if (fetchPolicy !== 'cache-and-network') {
+        else {
             reobserveOptions.fetchPolicy = 'network-only';
         }
         if (__DEV__ && variables && hasOwnProperty$1.call(variables, "variables")) {
             var queryDef = getQueryDefinition(this.options.query);
             var vars = queryDef.variableDefinitions;
             if (!vars || !vars.some(function (v) { return v.variable.name.value === "variables"; })) {
-                __DEV__ && tsInvariant.invariant.warn("Called refetch(" + JSON.stringify(variables) + ") for query " + (((_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 })?");
+                __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)) {
@@ -4035,7 +4211,7 @@ var ObservableQuery = (function (_super) {
             pollingInfo.interval === pollInterval) {
             return;
         }
-        __DEV__ ? tsInvariant.invariant(pollInterval, 'Attempted to start a polling query without a polling interval.') : tsInvariant.invariant(pollInterval, 12);
+        __DEV__ ? tsInvariant.invariant(pollInterval, 'Attempted to start a polling query without a polling interval.') : tsInvariant.invariant(pollInterval, 10);
         var info = pollingInfo || (this.pollingInfo = {});
         info.interval = pollInterval;
         var maybeFetch = function () {
@@ -4150,8 +4326,8 @@ 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);
+    if (__DEV__ && missing) {
+        __DEV__ && tsInvariant.invariant.debug("Missing cache result fields: ".concat(JSON.stringify(missing)), missing);
     }
 }
 function applyNextFetchPolicy(options) {
@@ -4332,7 +4508,7 @@ var LocalState = (function () {
                         }
                         else {
                             fragment = fragmentMap[selection.name.value];
-                            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named " + selection.name.value) : tsInvariant.invariant(fragment, 11);
+                            __DEV__ ? tsInvariant.invariant(fragment, "No fragment named ".concat(selection.name.value)) : tsInvariant.invariant(fragment, 9);
                         }
                         if (fragment && fragment.typeCondition) {
                             typeCondition = fragment.typeCondition.name.value;
@@ -4718,7 +4894,7 @@ var QueryManager = (function () {
         this.queries.forEach(function (_info, queryId) {
             _this.stopQueryNoBroadcast(queryId);
         });
-        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('QueryManager stopped while query was in flight') : new tsInvariant.InvariantError(13));
+        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('QueryManager stopped while query was in flight') : new tsInvariant.InvariantError(11));
     };
     QueryManager.prototype.cancelPendingFetches = function (error) {
         this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });
@@ -4731,10 +4907,10 @@ var QueryManager = (function () {
             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, 14);
+                        __DEV__ ? tsInvariant.invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.') : tsInvariant.invariant(mutation, 12);
                         __DEV__ ? tsInvariant.invariant(fetchPolicy === 'network-only' ||
                             fetchPolicy === 'no-cache', "Mutations support only 'network-only' or 'no-cache' fetchPolicy strings. The default `network-only` behavior automatically writes mutation results to the cache. Passing `no-cache` skips the cache write.") : tsInvariant.invariant(fetchPolicy === 'network-only' ||
-                            fetchPolicy === 'no-cache', 15);
+                            fetchPolicy === 'no-cache', 13);
                         mutationId = this.generateMutationId();
                         mutation = this.transform(mutation).document;
                         variables = this.getVariables(mutation, variables);
@@ -5019,10 +5195,10 @@ var QueryManager = (function () {
         var _this = this;
         if (queryId === void 0) { queryId = this.generateQueryId(); }
         __DEV__ ? tsInvariant.invariant(options.query, 'query option is required. You must specify your GraphQL document ' +
-            'in the query option.') : tsInvariant.invariant(options.query, 16);
-        __DEV__ ? tsInvariant.invariant(options.query.kind === 'Document', 'You must wrap the query string in a "gql" tag.') : tsInvariant.invariant(options.query.kind === 'Document', 17);
-        __DEV__ ? tsInvariant.invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.') : tsInvariant.invariant(!options.returnPartialData, 18);
-        __DEV__ ? tsInvariant.invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.') : tsInvariant.invariant(!options.pollInterval, 19);
+            'in the query option.') : tsInvariant.invariant(options.query, 14);
+        __DEV__ ? tsInvariant.invariant(options.query.kind === 'Document', 'You must wrap the query string in a "gql" tag.') : tsInvariant.invariant(options.query.kind === 'Document', 15);
+        __DEV__ ? tsInvariant.invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.') : tsInvariant.invariant(!options.returnPartialData, 16);
+        __DEV__ ? tsInvariant.invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.') : tsInvariant.invariant(!options.pollInterval, 17);
         return this.fetchQuery(queryId, options).finally(function () { return _this.stopQuery(queryId); });
     };
     QueryManager.prototype.generateQueryId = function () {
@@ -5047,7 +5223,7 @@ var QueryManager = (function () {
         if (options === void 0) { options = {
             discardWatches: true,
         }; }
-        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('Store reset while query was in flight (not completed in link chain)') : new tsInvariant.InvariantError(20));
+        this.cancelPendingFetches(__DEV__ ? new tsInvariant.InvariantError('Store reset while query was in flight (not completed in link chain)') : new tsInvariant.InvariantError(18));
         this.queries.forEach(function (queryInfo) {
             if (queryInfo.observableQuery) {
                 queryInfo.networkStatus = exports.NetworkStatus.loading;
@@ -5123,7 +5299,7 @@ var QueryManager = (function () {
         if (__DEV__ && queryNamesAndDocs.size) {
             queryNamesAndDocs.forEach(function (included, nameOrDoc) {
                 if (!included) {
-                    __DEV__ && tsInvariant.invariant.warn("Unknown query " + (typeof nameOrDoc === "string" ? "named " : "") + JSON.stringify(nameOrDoc, null, 2) + " requested in refetchQueries options.include array");
+                    __DEV__ && tsInvariant.invariant.warn("Unknown query ".concat(typeof nameOrDoc === "string" ? "named " : "").concat(JSON.stringify(nameOrDoc, null, 2), " requested in refetchQueries options.include array"));
                 }
             });
         }
@@ -5359,7 +5535,7 @@ var QueryManager = (function () {
                             if (result !== false) {
                                 results.set(oq, result);
                             }
-                            return false;
+                            return result;
                         }
                         if (onQueryUpdated !== null) {
                             includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });
@@ -5535,7 +5711,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(9);
+                "For more information, please visit: https://go.apollo.dev/c/docs") : new tsInvariant.InvariantError(7);
         }
         this.link = link;
         this.cache = cache;
@@ -5631,7 +5807,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', 10);
+            'using a different fetchPolicy, such as cache-first or network-only.') : tsInvariant.invariant(options.fetchPolicy !== 'cache-and-network', 8);
         if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {
             options = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: 'cache-first' });
         }
@@ -5714,7 +5890,7 @@ var ApolloClient = (function () {
         result.queries = queries;
         result.results = results;
         result.catch(function (error) {
-            __DEV__ && tsInvariant.invariant.debug("In client.refetchQueries, Promise.all promise rejected with error " + error);
+            __DEV__ && tsInvariant.invariant.debug("In client.refetchQueries, Promise.all promise rejected with error ".concat(error));
         });
         return result;
     };
@@ -5767,7 +5943,7 @@ var ApolloConsumer = function (props) {
     var ApolloContext = getApolloContext();
     return React__namespace.createElement(ApolloContext.Consumer, null, function (context) {
         __DEV__ ? tsInvariant.invariant(context && context.client, 'Could not find "client" in the context of ApolloConsumer. ' +
-            'Wrap the root component in an <ApolloProvider>.') : tsInvariant.invariant(context && context.client, 27);
+            'Wrap the root component in an <ApolloProvider>.') : tsInvariant.invariant(context && context.client, 25);
         return props.children(context.client);
     });
 };
@@ -5781,15 +5957,17 @@ var ApolloProvider = function (_a) {
             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);
+            'sure you pass in your client via the "client" prop.') : tsInvariant.invariant(context.client, 26);
         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);
+function useApolloClient(override) {
+    var context = React.useContext(getApolloContext());
+    var client = override || context.client;
+    __DEV__ ? tsInvariant.invariant(!!client, 'Could not find "client" in the context or passed in as an option. ' +
+        'Wrap the root component in an <ApolloProvider>, or pass an ApolloClient' +
+        'ApolloClient instance in via options.') : tsInvariant.invariant(!!client, 29);
     return client;
 }
 
@@ -5820,9 +5998,9 @@ function parser(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 " +
+    __DEV__ ? tsInvariant.invariant(!!document && !!document.kind, "Argument of ".concat(document, " passed to parser was not a valid GraphQL ") +
         "DocumentNode. You may need to use 'graphql-tag' or another method " +
-        "to convert your operation into a document") : tsInvariant.invariant(!!document && !!document.kind, 34);
+        "to convert your operation into a document") : tsInvariant.invariant(!!document && !!document.kind, 30);
     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';
@@ -5836,11 +6014,11 @@ function parser(document) {
     __DEV__ ? tsInvariant.invariant(!fragments.length ||
         (queries.length || mutations.length || subscriptions.length), "Passing only a fragment to 'graphql' is not yet supported. " +
         "You must include a query, subscription or mutation as well") : tsInvariant.invariant(!fragments.length ||
-        (queries.length || mutations.length || subscriptions.length), 35);
+        (queries.length || mutations.length || subscriptions.length), 31);
     __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);
+        "".concat(document, " had ").concat(queries.length, " queries, ").concat(subscriptions.length, " ") +
+        "subscriptions and ".concat(mutations.length, " mutations. ") +
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(queries.length + mutations.length + subscriptions.length <= 1, 32);
     type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;
     if (!queries.length && !mutations.length)
         type = exports.DocumentType.Subscription;
@@ -5849,9 +6027,9 @@ function parser(document) {
         : 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);
+    __DEV__ ? tsInvariant.invariant(definitions.length === 1, "react-apollo only supports one definition per HOC. ".concat(document, " had ") +
+        "".concat(definitions.length, " definitions. ") +
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(definitions.length === 1, 33);
     var definition = definitions[0];
     variables = definition.variableDefinitions || [];
     if (definition.name && definition.name.kind === 'Name') {
@@ -5864,711 +6042,470 @@ function parser(document) {
     cache.set(document, payload);
     return payload;
 }
+function verifyDocumentType(document, type) {
+    var operation = parser(document);
+    var requiredOperationName = operationName(type);
+    var usedOperationName = operationName(operation.type);
+    __DEV__ ? tsInvariant.invariant(operation.type === type, "Running a ".concat(requiredOperationName, " requires a graphql ") +
+        "".concat(requiredOperationName, ", but a ").concat(usedOperationName, " was used instead.")) : tsInvariant.invariant(operation.type === type, 34);
+}
 
-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;
+function useQuery(query, options) {
+    var _a;
+    var context = React.useContext(getApolloContext());
+    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
+    verifyDocumentType(query, exports.DocumentType.Query);
+    var _b = React.useState(function () {
+        var watchQueryOptions = createWatchQueryOptions(query, options);
+        var obsQuery = null;
+        if (context.renderPromises) {
+            obsQuery = context.renderPromises.getSSRObservable(watchQueryOptions);
+        }
+        if (!obsQuery) {
+            obsQuery = client.watchQuery(watchQueryOptions);
+            if (context.renderPromises) {
+                context.renderPromises.registerSSRObservable(obsQuery, watchQueryOptions);
+            }
+        }
+        if (context.renderPromises &&
+            (options === null || options === void 0 ? void 0 : options.ssr) !== false &&
+            !(options === null || options === void 0 ? void 0 : options.skip) &&
+            obsQuery.getCurrentResult().loading) {
+            context.renderPromises.addQueryPromise({
+                getOptions: function () { return createWatchQueryOptions(query, options); },
+                fetchData: function () { return new Promise(function (resolve) {
+                    var sub = obsQuery.subscribe({
+                        next: function (result) {
+                            if (!result.loading) {
+                                resolve();
+                                sub.unsubscribe();
+                            }
+                        },
+                        error: function () {
+                            resolve();
+                            sub.unsubscribe();
+                        },
+                        complete: function () {
+                            resolve();
+                        },
+                    });
+                }); },
+            }, function () { return null; });
         }
-    };
-    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.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 obsQuery;
+    }), obsQuery = _b[0], setObsQuery = _b[1];
+    var _c = React.useState(function () {
+        var _a, _b;
+        var result = obsQuery.getCurrentResult();
+        if (!result.loading && options) {
+            if (result.error) {
+                (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, result.error);
             }
-            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);
+            else if (result.data) {
+                (_b = options.onCompleted) === null || _b === void 0 ? void 0 : _b.call(options, result.data);
             }
         }
-    };
-    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();
+        return result;
+    }), result = _c[0], setResult = _c[1];
+    var ref = React.useRef({
+        client: client,
+        query: query,
+        options: options,
+        result: result,
+        previousData: void 0,
+        watchQueryOptions: createWatchQueryOptions(query, options),
+    });
+    React.useEffect(function () {
+        var _a, _b;
+        var watchQueryOptions = createWatchQueryOptions(query, options);
+        var nextResult;
+        if (ref.current.client !== client || !equality.equal(ref.current.query, query)) {
+            var obsQuery_1 = client.watchQuery(watchQueryOptions);
+            setObsQuery(obsQuery_1);
+            nextResult = obsQuery_1.getCurrentResult();
+        }
+        else if (!equality.equal(ref.current.watchQueryOptions, watchQueryOptions)) {
+            obsQuery.setOptions(watchQueryOptions).catch(function () { });
+            nextResult = obsQuery.getCurrentResult();
+            ref.current.watchQueryOptions = watchQueryOptions;
+        }
+        if (nextResult) {
+            var previousResult = ref.current.result;
+            if (previousResult.data) {
+                ref.current.previousData = previousResult.data;
+            }
+            setResult(ref.current.result = nextResult);
+            if (!nextResult.loading && options) {
+                if (!result.loading) {
+                    if (result.error) {
+                        (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, result.error);
+                    }
+                    else if (result.data) {
+                        (_b = options.onCompleted) === null || _b === void 0 ? void 0 : _b.call(options, result.data);
+                    }
                 }
             }
-        });
-    };
-    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 });
+        Object.assign(ref.current, { client: client, query: query });
+    }, [obsQuery, client, query, options]);
+    React.useEffect(function () {
+        if (context.renderPromises) {
+            return;
         }
-        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 });
+        var subscription = obsQuery.subscribe(onNext, onError);
+        function onNext() {
+            var _a, _b;
+            var previousResult = ref.current.result;
+            var result = obsQuery.getCurrentResult();
+            if (previousResult &&
+                previousResult.loading === result.loading &&
+                previousResult.networkStatus === result.networkStatus &&
+                equality.equal(previousResult.data, result.data)) {
+                return;
             }
-            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
-                });
+            if (previousResult.data) {
+                ref.current.previousData = previousResult.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;
-                }
+            setResult(ref.current.result = result);
+            if (!result.loading) {
+                (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onCompleted) === null || _b === void 0 ? void 0 : _b.call(_a, result.data);
             }
         }
-        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);
+        function onError(error) {
+            var _a, _b;
+            var last = obsQuery["last"];
+            subscription.unsubscribe();
+            try {
+                obsQuery.resetLastResults();
+                subscription = obsQuery.subscribe(onNext, onError);
             }
-            else if (onError && error) {
-                onError(error);
+            finally {
+                obsQuery["last"] = last;
             }
-        }
-    };
-    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;
+            if (!error.hasOwnProperty('graphQLErrors')) {
+                throw error;
             }
-        }
-    };
-    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
+            var previousResult = ref.current.result;
+            if ((previousResult && previousResult.loading) ||
+                !equality.equal(error, previousResult.error)) {
+                setResult(ref.current.result = {
+                    data: previousResult.data,
+                    error: error,
+                    loading: false,
+                    networkStatus: exports.NetworkStatus.error,
+                });
+                (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+            }
+        }
+        return function () { return subscription.unsubscribe(); };
+    }, [obsQuery, context.renderPromises, client.disableNetworkFetches]);
+    var partial;
+    (_a = result, partial = _a.partial, result = tslib.__rest(_a, ["partial"]));
+    {
+        if (partial &&
+            (options === null || options === void 0 ? void 0 : options.partialRefetch) &&
+            !result.loading &&
+            (!result.data || Object.keys(result.data).length === 0) &&
+            obsQuery.options.fetchPolicy !== 'cache-only') {
+            result = tslib.__assign(tslib.__assign({}, result), { loading: true, networkStatus: exports.NetworkStatus.refetch });
+            obsQuery.refetch();
+        }
+        if (context.renderPromises &&
+            (options === null || options === void 0 ? void 0 : options.ssr) !== false &&
+            !(options === null || options === void 0 ? void 0 : options.skip) &&
+            result.loading) {
+            obsQuery.setOptions(createWatchQueryOptions(query, options)).catch(function () { });
+        }
+        Object.assign(ref.current, { options: options });
+    }
+    if ((context.renderPromises || client.disableNetworkFetches) &&
+        (options === null || options === void 0 ? void 0 : options.ssr) === false) {
+        result = ref.current.result = {
+            loading: true,
+            data: void 0,
+            error: void 0,
+            networkStatus: exports.NetworkStatus.loading,
         };
-    };
-    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();
-            }
-        }, []);
+    else if ((options === null || options === void 0 ? void 0 : options.skip) || (options === null || options === void 0 ? void 0 : options.fetchPolicy) === 'standby') {
+        result = {
+            loading: false,
+            data: void 0,
+            error: void 0,
+            networkStatus: exports.NetworkStatus.ready,
+        };
+    }
+    if (result.errors && result.errors.length) {
+        result = tslib.__assign(tslib.__assign({}, result), { error: result.error || new ApolloError({ graphQLErrors: result.errors }) });
+    }
+    var obsQueryFields = React.useMemo(function () { return ({
+        refetch: obsQuery.refetch.bind(obsQuery),
+        fetchMore: obsQuery.fetchMore.bind(obsQuery),
+        updateQuery: obsQuery.updateQuery.bind(obsQuery),
+        startPolling: obsQuery.startPolling.bind(obsQuery),
+        stopPolling: obsQuery.stopPolling.bind(obsQuery),
+        subscribeToMore: obsQuery.subscribeToMore.bind(obsQuery),
+    }); }, [obsQuery]);
+    return tslib.__assign(tslib.__assign(tslib.__assign({}, obsQueryFields), { variables: createWatchQueryOptions(query, options).variables, client: client, called: true, previousData: ref.current.previousData }), result);
+}
+function createWatchQueryOptions(query, options) {
+    var _a;
+    if (options === void 0) { options = {}; }
+    var skip = options.skip; options.ssr; options.onCompleted; options.onError; options.displayName; var watchQueryOptions = tslib.__rest(options, ["skip", "ssr", "onCompleted", "onError", "displayName"]);
+    if (skip) {
+        watchQueryOptions.fetchPolicy = 'standby';
+    }
+    else if (((_a = watchQueryOptions.context) === null || _a === void 0 ? void 0 : _a.renderPromises) &&
+        (watchQueryOptions.fetchPolicy === 'network-only' ||
+            watchQueryOptions.fetchPolicy === 'cache-and-network')) {
+        watchQueryOptions.fetchPolicy = 'cache-first';
+    }
+    else if (!watchQueryOptions.fetchPolicy) {
+        watchQueryOptions.fetchPolicy = 'cache-first';
     }
+    if (!watchQueryOptions.variables) {
+        watchQueryOptions.variables = {};
+    }
+    return tslib.__assign({ query: query }, watchQueryOptions);
 }
 
-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();
+var EAGER_METHODS = [
+    'refetch',
+    'fetchMore',
+    'updateQuery',
+    'startPolling',
+    'subscribeToMore',
+];
+function useLazyQuery(query, options) {
+    var _a = React.useState({
+        called: false,
+        resolves: [],
+    }), execution = _a[0], setExecution = _a[1];
+    var execute = React.useCallback(function (executeOptions) {
+        var resolve;
+        var promise = new Promise(function (resolve1) { return (resolve = resolve1); });
+        setExecution(function (execution) {
+            if (execution.called) {
+                result && result.refetch(executeOptions === null || executeOptions === void 0 ? void 0 : executeOptions.variables);
             }
-        }
-    }));
-    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);
-    }
+            return {
+                called: true,
+                resolves: tslib.__spreadArray(tslib.__spreadArray([], execution.resolves, true), [resolve], false),
+                options: executeOptions,
+            };
+        });
+        return promise;
+    }, []);
+    var result = useQuery(query, tslib.__assign(tslib.__assign(tslib.__assign({}, options), execution.options), { fetchPolicy: execution.called ? options === null || options === void 0 ? void 0 : options.fetchPolicy : 'standby', skip: undefined }));
     React.useEffect(function () {
-        return function () {
-            queryData.cleanup();
-            queryDataRef.current = void 0;
+        var resolves = execution.resolves;
+        if (!result.loading && resolves.length) {
+            setExecution(function (execution) { return (tslib.__assign(tslib.__assign({}, execution), { resolves: [] })); });
+            resolves.forEach(function (resolve) { return resolve(result); });
+        }
+    }, [result, execution]);
+    if (!execution.called) {
+        result = tslib.__assign(tslib.__assign({}, result), { loading: false, data: void 0, error: void 0, called: false });
+        var _loop_1 = function (key) {
+            var method = result[key];
+            result[key] = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                setExecution(function (execution) { return (tslib.__assign(tslib.__assign({}, execution), { called: true })); });
+                return method.apply(void 0, args);
+            };
         };
-    }, []);
-    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);
+        for (var _i = 0, EAGER_METHODS_1 = EAGER_METHODS; _i < EAGER_METHODS_1.length; _i++) {
+            var key = EAGER_METHODS_1[_i];
+            _loop_1(key);
+        }
+    }
+    return [execute, result];
 }
 
 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
+    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
+    verifyDocumentType(mutation, exports.DocumentType.Mutation);
+    var _a = React.useState({
+        called: false,
+        loading: false,
+        client: client,
+    }), result = _a[0], setResult = _a[1];
+    var ref = React.useRef({
+        result: result,
+        mutationId: 0,
+        isMounted: true,
+        client: client,
+        mutation: mutation,
+        options: options,
+    });
+    {
+        Object.assign(ref.current, { client: client, options: options, mutation: mutation });
+    }
+    var execute = React.useCallback(function (executeOptions) {
+        if (executeOptions === void 0) { executeOptions = {}; }
+        var _a = ref.current, client = _a.client, options = _a.options, mutation = _a.mutation;
+        var baseOptions = tslib.__assign(tslib.__assign({}, options), { mutation: mutation });
+        if (!ref.current.result.loading && !baseOptions.ignoreResults) {
+            setResult(ref.current.result = {
+                loading: true,
+                error: void 0,
+                data: void 0,
+                called: true,
+                client: client,
             });
         }
-        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);
+        var mutationId = ++ref.current.mutationId;
+        var clientOptions = mergeOptions(baseOptions, executeOptions);
+        return client.mutate(clientOptions).then(function (response) {
+            var _a, _b;
+            var data = response.data, errors = response.errors;
+            var error = errors && errors.length > 0
+                ? new ApolloError({ graphQLErrors: errors })
+                : void 0;
+            if (mutationId === ref.current.mutationId &&
+                !clientOptions.ignoreResults) {
+                var result_1 = {
+                    called: true,
+                    loading: false,
+                    data: data,
+                    error: error,
+                    client: client,
+                };
+                if (ref.current.isMounted && !equality.equal(ref.current.result, result_1)) {
+                    setResult(ref.current.result = result_1);
+                }
+            }
+            (_a = baseOptions.onCompleted) === null || _a === void 0 ? void 0 : _a.call(baseOptions, response.data);
+            (_b = executeOptions.onCompleted) === null || _b === void 0 ? void 0 : _b.call(executeOptions, response.data);
+            return response;
+        }).catch(function (error) {
+            var _a, _b;
+            if (mutationId === ref.current.mutationId &&
+                ref.current.isMounted) {
+                var result_2 = {
+                    loading: false,
+                    error: error,
+                    data: void 0,
+                    called: true,
+                    client: client,
+                };
+                if (!equality.equal(ref.current.result, result_2)) {
+                    setResult(ref.current.result = result_2);
+                }
+            }
+            if (baseOptions.onError || clientOptions.onError) {
+                (_a = baseOptions.onError) === null || _a === void 0 ? void 0 : _a.call(baseOptions, error);
+                (_b = executeOptions.onError) === null || _b === void 0 ? void 0 : _b.call(executeOptions, error);
+                return { data: void 0, errors: error };
+            }
+            throw error;
+        });
+    }, []);
+    var reset = React.useCallback(function () {
+        setResult({ called: false, loading: false, client: client });
+    }, []);
+    React.useEffect(function () { return function () {
+        ref.current.isMounted = false;
+    }; }, []);
+    return [execute, tslib.__assign({ reset: reset }, result)];
 }
 
 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,
+    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
+    verifyDocumentType(subscription, exports.DocumentType.Subscription);
+    var _a = React.useState({
+        loading: !(options === null || options === void 0 ? void 0 : options.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
-            });
+        variables: options === null || options === void 0 ? void 0 : options.variables,
+    }), result = _a[0], setResult = _a[1];
+    var _b = React.useState(function () {
+        if (options === null || options === void 0 ? void 0 : options.skip) {
+            return null;
         }
-        return subscriptionDataRef.current;
-    }
-    var subscriptionData = getSubscriptionDataRef();
-    subscriptionData.setOptions(updatedOptions, true);
-    subscriptionData.context = context;
-    if (__DEV__) {
-        useAfterFastRefresh(forceUpdate);
-    }
-    React.useEffect(function () { return subscriptionData.afterExecute(); });
+        return client.subscribe({
+            query: subscription,
+            variables: options === null || options === void 0 ? void 0 : options.variables,
+            fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
+            context: options === null || options === void 0 ? void 0 : options.context,
+        });
+    }), observable = _b[0], setObservable = _b[1];
+    var ref = React.useRef({ client: client, subscription: subscription, options: options });
+    React.useEffect(function () {
+        var _a, _b, _c, _d;
+        var shouldResubscribe = options === null || options === void 0 ? void 0 : options.shouldResubscribe;
+        if (typeof shouldResubscribe === 'function') {
+            shouldResubscribe = !!shouldResubscribe(options);
+        }
+        if ((options === null || options === void 0 ? void 0 : options.skip) && !(options === null || options === void 0 ? void 0 : options.skip) !== !((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.skip)) {
+            setResult({
+                loading: false,
+                data: void 0,
+                error: void 0,
+                variables: options === null || options === void 0 ? void 0 : options.variables,
+            });
+            setObservable(null);
+        }
+        else if (shouldResubscribe !== false && (client !== ref.current.client ||
+            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))) {
+            setResult({
+                loading: true,
+                data: void 0,
+                error: void 0,
+                variables: options === null || options === void 0 ? void 0 : options.variables,
+            });
+            setObservable(client.subscribe({
+                query: subscription,
+                variables: options === null || options === void 0 ? void 0 : options.variables,
+                fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
+                context: options === null || options === void 0 ? void 0 : options.context,
+            }));
+        }
+        Object.assign(ref.current, { client: client, subscription: subscription, options: options });
+    }, [client, subscription, options]);
     React.useEffect(function () {
+        if (!observable) {
+            return;
+        }
+        var subscription = observable.subscribe({
+            next: function (fetchResult) {
+                var _a, _b;
+                var result = {
+                    loading: false,
+                    data: fetchResult.data,
+                    error: void 0,
+                    variables: options === null || options === void 0 ? void 0 : options.variables,
+                };
+                setResult(result);
+                (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onSubscriptionData) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                    client: client,
+                    subscriptionData: result
+                });
+            },
+            error: function (error) {
+                setResult({
+                    loading: false,
+                    data: void 0,
+                    error: error,
+                    variables: options === null || options === void 0 ? void 0 : options.variables,
+                });
+            },
+            complete: function () {
+                var _a, _b;
+                (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onSubscriptionComplete) === null || _b === void 0 ? void 0 : _b.call(_a);
+            },
+        });
         return function () {
-            subscriptionData.cleanup();
-            subscriptionDataRef.current = void 0;
+            subscription.unsubscribe();
         };
-    }, []);
-    return subscriptionData.execute(result);
+    }, [observable]);
+    return result;
 }
 
 function useReactiveVar(rv) {
@@ -6609,6 +6546,7 @@ exports.concat = concat;
 exports.createHttpLink = createHttpLink;
 exports.createSignalIfSupported = createSignalIfSupported;
 exports.defaultDataIdFromObject = defaultDataIdFromObject;
+exports.defaultPrinter = defaultPrinter;
 exports.empty = empty;
 exports.execute = execute;
 exports.fallbackHttpConfig = fallbackHttpConfig;
@@ -6627,6 +6565,7 @@ exports.parser = parser;
 exports.resetApolloContext = getApolloContext;
 exports.rewriteURIForGET = rewriteURIForGET;
 exports.selectHttpOptionsAndBody = selectHttpOptionsAndBody;
+exports.selectHttpOptionsAndBodyInternal = selectHttpOptionsAndBodyInternal;
 exports.selectURI = selectURI;
 exports.serializeFetchParameter = serializeFetchParameter;
 exports.split = split;
@@ -6638,4 +6577,4 @@ exports.useMutation = useMutation;
 exports.useQuery = useQuery;
 exports.useReactiveVar = useReactiveVar;
 exports.useSubscription = useSubscription;
-//# sourceMappingURL=apollo-client.cjs.js.map
+//# sourceMappingURL=apollo-client.cjs.map