@apollo/client 3.4.3 → 3.4.7

package/apollo-client.cjs.js

@@ -2,17 +2,32 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var tslib = require('tslib');
 var tsInvariant = require('ts-invariant');
+var equality = require('@wry/equality');
 var process$1 = require('ts-invariant/process');
 var graphql = require('graphql');
-var tslib = require('tslib');
-var equality = require('@wry/equality');
 var zenObservableTs = require('zen-observable-ts');
 require('symbol-observable');
 var optimism = require('optimism');
 var context = require('@wry/context');
 var trie = require('@wry/trie');
 var graphqlTag = require('graphql-tag');
+var React = require('react');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            n[k] = e[k];
+        });
+    }
+    n['default'] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
 function maybe(thunk) {
     try {
@@ -1292,7 +1307,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.4.3';
+var version = '3.4.7';
 
 var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
 function parseAndCheckHttpResponse(operations) {
@@ -1460,12 +1475,12 @@ function rewriteURIForGET(chosenURI, body) {
     return { newURI: newURI };
 }
 
+var backupFetch = maybe(function () { return fetch; });
 var createHttpLink = function (linkOptions) {
     if (linkOptions === void 0) { linkOptions = {}; }
-    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, fetcher = linkOptions.fetch, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, _b = linkOptions.includeUnusedVariables, includeUnusedVariables = _b === void 0 ? false : _b, requestOptions = tslib.__rest(linkOptions, ["uri", "fetch", "includeExtensions", "useGETForQueries", "includeUnusedVariables"]);
-    checkFetcher(fetcher);
-    if (!fetcher) {
-        fetcher = fetch;
+    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, preferredFetch = linkOptions.fetch, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, _b = linkOptions.includeUnusedVariables, includeUnusedVariables = _b === void 0 ? false : _b, requestOptions = tslib.__rest(linkOptions, ["uri", "fetch", "includeExtensions", "useGETForQueries", "includeUnusedVariables"]);
+    if (__DEV__) {
+        checkFetcher(preferredFetch || backupFetch);
     }
     var linkConfig = {
         http: { includeExtensions: includeExtensions },
@@ -1540,7 +1555,8 @@ var createHttpLink = function (linkOptions) {
             }
         }
         return new zenObservableTs.Observable(function (observer) {
-            fetcher(chosenURI, options)
+            var currentFetch = preferredFetch || maybe(function () { return fetch; }) || backupFetch;
+            currentFetch(chosenURI, options)
                 .then(function (response) {
                 operation.setContext({ response: response });
                 return response;
@@ -2542,7 +2558,7 @@ var StoreWriter = (function () {
         context.incomingById.forEach(function (_a, dataId) {
             var fields = _a.fields, mergeTree = _a.mergeTree, selections = _a.selections;
             var entityRef = makeReference(dataId);
-            if (mergeTree.map.size) {
+            if (mergeTree && mergeTree.map.size) {
                 var applied = _this.applyMerges(mergeTree, entityRef, fields, context);
                 if (isReference(applied)) {
                     return;
@@ -2560,7 +2576,7 @@ var StoreWriter = (function () {
                     }
                 });
                 var hasMergeFunction_1 = function (storeFieldName) {
-                    var childTree = mergeTree.map.get(storeFieldName);
+                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);
                     return Boolean(childTree && childTree.info && childTree.info.merge);
                 };
                 Object.keys(fields).forEach(function (storeFieldName) {
@@ -2669,7 +2685,7 @@ var StoreWriter = (function () {
             else {
                 context.incomingById.set(dataId, {
                     fields: incomingFields,
-                    mergeTree: mergeTree,
+                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
                     selections: selections,
                 });
             }
@@ -3766,7 +3782,7 @@ var ObservableQuery = (function (_super) {
         };
         _this.isTornDown = false;
         _this.options = options;
-        _this.queryId = queryManager.generateQueryId();
+        _this.queryId = queryInfo.queryId || queryManager.generateQueryId();
         var opDef = getOperationDefinition(options.query);
         _this.queryName = opDef && opDef.name && opDef.name.value;
         _this.initialFetchPolicy = options.fetchPolicy || "cache-first";
@@ -3823,12 +3839,13 @@ var ObservableQuery = (function (_super) {
             else if (fetchPolicy !== "no-cache") {
                 result.partial = true;
             }
-            if (!diff.complete &&
+            if (__DEV__ &&
+                !diff.complete &&
                 !this.options.partialRefetch &&
                 !result.loading &&
                 !result.data &&
                 !result.error) {
-                result.error = new ApolloError({ clientErrors: diff.missing });
+                logMissingFieldErrors(diff.missing);
             }
         }
         if (saveAsLastResult) {
@@ -4103,6 +4120,11 @@ fixObservableSubclass(ObservableQuery);
 function defaultSubscriptionObserverErrorCallback(error) {
     __DEV__ && tsInvariant.invariant.error('Unhandled error', error.message, error.stack);
 }
+function logMissingFieldErrors(missing) {
+    if (__DEV__ && isNonEmptyArray(missing)) {
+        __DEV__ && tsInvariant.invariant.debug("Missing cache result fields: " + missing.map(function (m) { return m.path.join('.'); }).join(', '), missing);
+    }
+}
 function applyNextFetchPolicy(options) {
     var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a, nextFetchPolicy = options.nextFetchPolicy;
     if (nextFetchPolicy) {
@@ -4390,8 +4412,9 @@ function cancelNotifyTimeout(info) {
     }
 }
 var QueryInfo = (function () {
-    function QueryInfo(cache) {
-        this.cache = cache;
+    function QueryInfo(queryManager, queryId) {
+        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }
+        this.queryId = queryId;
         this.listeners = new Set();
         this.document = null;
         this.lastRequestId = 1;
@@ -4399,6 +4422,7 @@ var QueryInfo = (function () {
         this.stopped = false;
         this.dirty = false;
         this.observableQuery = null;
+        var cache = this.cache = queryManager.cache;
         if (!destructiveMethodCounts.has(cache)) {
             destructiveMethodCounts.set(cache, 0);
             wrapDestructiveCacheMethod(cache, "evict");
@@ -4672,22 +4696,24 @@ var QueryManager = (function () {
         this.fetchCancelFns.clear();
     };
     QueryManager.prototype.mutate = function (_a) {
-        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueries = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, onQueryUpdated = _a.onQueryUpdated, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, keepRootFields = _a.keepRootFields, context = _a.context;
+        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueries = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, onQueryUpdated = _a.onQueryUpdated, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, _e = _a.fetchPolicy, fetchPolicy = _e === void 0 ? 'network-only' : _e, keepRootFields = _a.keepRootFields, context = _a.context;
         return tslib.__awaiter(this, void 0, void 0, function () {
             var mutationId, mutationStoreValue, self;
-            return tslib.__generator(this, function (_e) {
-                switch (_e.label) {
+            return tslib.__generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         __DEV__ ? tsInvariant.invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.') : tsInvariant.invariant(mutation, 15);
-                        __DEV__ ? tsInvariant.invariant(!fetchPolicy || fetchPolicy === 'no-cache', "Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.") : tsInvariant.invariant(!fetchPolicy || fetchPolicy === 'no-cache', 16);
+                        __DEV__ ? tsInvariant.invariant(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', 16);
                         mutationId = this.generateMutationId();
                         mutation = this.transform(mutation).document;
                         variables = this.getVariables(mutation, variables);
                         if (!this.transform(mutation).hasClientExports) return [3, 2];
                         return [4, this.localState.addExportedVariables(mutation, variables, context)];
                     case 1:
-                        variables = (_e.sent());
-                        _e.label = 2;
+                        variables = (_f.sent());
+                        _f.label = 2;
                     case 2:
                         mutationStoreValue = this.mutationStore &&
                             (this.mutationStore[mutationId] = {
@@ -4946,7 +4972,7 @@ var QueryManager = (function () {
         if (typeof options.notifyOnNetworkStatusChange === 'undefined') {
             options.notifyOnNetworkStatusChange = false;
         }
-        var queryInfo = new QueryInfo(this.cache);
+        var queryInfo = new QueryInfo(this);
         var observable = new ObservableQuery({
             queryManager: this,
             queryInfo: queryInfo,
@@ -5062,6 +5088,7 @@ var QueryManager = (function () {
                     queryInfo: queryInfo,
                     options: tslib.__assign(tslib.__assign({}, options), { fetchPolicy: "network-only" }),
                 });
+                tsInvariant.invariant(oq.queryId === queryId);
                 queryInfo.setObservableQuery(oq);
                 queries.set(queryId, oq);
             });
@@ -5356,10 +5383,9 @@ var QueryManager = (function () {
             if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || exports.NetworkStatus.loading; }
             var data = diff.result;
             if (__DEV__ &&
-                isNonEmptyArray(diff.missing) &&
-                !equality.equal(data, {}) &&
-                !returnPartialData) {
-                __DEV__ && tsInvariant.invariant.debug("Missing cache result fields: " + diff.missing.map(function (m) { return m.path.join('.'); }).join(', '), diff.missing);
+                !returnPartialData &&
+                !equality.equal(data, {})) {
+                logMissingFieldErrors(diff.missing);
             }
             var fromData = function (data) { return zenObservableTs.Observable.of(tslib.__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true }))); };
             if (data && _this.transform(query).hasForcedResolvers) {
@@ -5446,7 +5472,7 @@ var QueryManager = (function () {
     };
     QueryManager.prototype.getQuery = function (queryId) {
         if (queryId && !this.queries.has(queryId)) {
-            this.queries.set(queryId, new QueryInfo(this.cache));
+            this.queries.set(queryId, new QueryInfo(this, queryId));
         }
         return this.queries.get(queryId);
     };
@@ -5689,7 +5715,841 @@ var ApolloClient = (function () {
     return ApolloClient;
 }());
 
-tsInvariant.setVerbosity(DEV ? "log" : "silent");
+var cache$1 = new (canUseWeakMap ? WeakMap : Map)();
+function getApolloContext() {
+    var context = cache$1.get(React__namespace.createContext);
+    if (!context) {
+        context = React__namespace.createContext({});
+        context.displayName = 'ApolloContext';
+        cache$1.set(React__namespace.createContext, context);
+    }
+    return context;
+}
+
+var ApolloConsumer = function (props) {
+    var ApolloContext = getApolloContext();
+    return React__namespace.createElement(ApolloContext.Consumer, null, function (context) {
+        __DEV__ ? tsInvariant.invariant(context && context.client, 'Could not find "client" in the context of ApolloConsumer. ' +
+            'Wrap the root component in an <ApolloProvider>.') : tsInvariant.invariant(context && context.client, 30);
+        return props.children(context.client);
+    });
+};
+
+var ApolloProvider = function (_a) {
+    var client = _a.client, children = _a.children;
+    var ApolloContext = getApolloContext();
+    return React__namespace.createElement(ApolloContext.Consumer, null, function (context) {
+        if (context === void 0) { context = {}; }
+        if (client && context.client !== client) {
+            context = Object.assign({}, context, { client: client });
+        }
+        __DEV__ ? tsInvariant.invariant(context.client, 'ApolloProvider was not passed a client instance. Make ' +
+            'sure you pass in your client via the "client" prop.') : tsInvariant.invariant(context.client, 31);
+        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, 36);
+    return client;
+}
+
+exports.DocumentType = void 0;
+(function (DocumentType) {
+    DocumentType[DocumentType["Query"] = 0] = "Query";
+    DocumentType[DocumentType["Mutation"] = 1] = "Mutation";
+    DocumentType[DocumentType["Subscription"] = 2] = "Subscription";
+})(exports.DocumentType || (exports.DocumentType = {}));
+var cache = new Map();
+function operationName(type) {
+    var name;
+    switch (type) {
+        case exports.DocumentType.Query:
+            name = 'Query';
+            break;
+        case exports.DocumentType.Mutation:
+            name = 'Mutation';
+            break;
+        case exports.DocumentType.Subscription:
+            name = 'Subscription';
+            break;
+    }
+    return name;
+}
+function parser(document) {
+    var cached = cache.get(document);
+    if (cached)
+        return cached;
+    var variables, type, name;
+    __DEV__ ? tsInvariant.invariant(!!document && !!document.kind, "Argument of " + document + " passed to parser was not a valid GraphQL " +
+        "DocumentNode. You may need to use 'graphql-tag' or another method " +
+        "to convert your operation into a document") : tsInvariant.invariant(!!document && !!document.kind, 38);
+    var fragments = document.definitions.filter(function (x) { return x.kind === 'FragmentDefinition'; });
+    var queries = document.definitions.filter(function (x) {
+        return x.kind === 'OperationDefinition' && x.operation === 'query';
+    });
+    var mutations = document.definitions.filter(function (x) {
+        return x.kind === 'OperationDefinition' && x.operation === 'mutation';
+    });
+    var subscriptions = document.definitions.filter(function (x) {
+        return x.kind === 'OperationDefinition' && x.operation === 'subscription';
+    });
+    __DEV__ ? tsInvariant.invariant(!fragments.length ||
+        (queries.length || mutations.length || subscriptions.length), "Passing only a fragment to 'graphql' is not yet supported. " +
+        "You must include a query, subscription or mutation as well") : tsInvariant.invariant(!fragments.length ||
+        (queries.length || mutations.length || subscriptions.length), 39);
+    __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, 40);
+    type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;
+    if (!queries.length && !mutations.length)
+        type = exports.DocumentType.Subscription;
+    var definitions = queries.length
+        ? queries
+        : mutations.length
+            ? mutations
+            : subscriptions;
+    __DEV__ ? tsInvariant.invariant(definitions.length === 1, "react-apollo only supports one definition per HOC. " + document + " had " +
+        (definitions.length + " definitions. ") +
+        "You can use 'compose' to join multiple operation types to a component") : tsInvariant.invariant(definitions.length === 1, 41);
+    var definition = definitions[0];
+    variables = definition.variableDefinitions || [];
+    if (definition.name && definition.name.kind === 'Name') {
+        name = definition.name.value;
+    }
+    else {
+        name = 'data';
+    }
+    var payload = { name: name, type: type, variables: variables };
+    cache.set(document, payload);
+    return payload;
+}
+
+var OperationData = (function () {
+    function OperationData(options, context) {
+        this.isMounted = false;
+        this.previousOptions = {};
+        this.context = {};
+        this.options = {};
+        this.options = options || {};
+        this.context = context || {};
+    }
+    OperationData.prototype.getOptions = function () {
+        return this.options;
+    };
+    OperationData.prototype.setOptions = function (newOptions, storePrevious) {
+        if (storePrevious === void 0) { storePrevious = false; }
+        if (storePrevious && !equality.equal(this.options, newOptions)) {
+            this.previousOptions = this.options;
+        }
+        this.options = newOptions;
+    };
+    OperationData.prototype.unmount = function () {
+        this.isMounted = false;
+    };
+    OperationData.prototype.refreshClient = function () {
+        var client = (this.options && this.options.client) ||
+            (this.context && this.context.client);
+        __DEV__ ? tsInvariant.invariant(!!client, 'Could not find "client" in the context or passed in as an option. ' +
+            'Wrap the root component in an <ApolloProvider>, or pass an ' +
+            'ApolloClient instance in via options.') : tsInvariant.invariant(!!client, 32);
+        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, 33);
+    };
+    return OperationData;
+}());
+
+var SubscriptionData = (function (_super) {
+    tslib.__extends(SubscriptionData, _super);
+    function SubscriptionData(_a) {
+        var options = _a.options, context = _a.context, setResult = _a.setResult;
+        var _this = _super.call(this, options, context) || this;
+        _this.currentObservable = {};
+        _this.setResult = setResult;
+        _this.initialize(options);
+        return _this;
+    }
+    SubscriptionData.prototype.execute = function (result) {
+        if (this.getOptions().skip === true) {
+            this.cleanup();
+            return {
+                loading: false,
+                error: undefined,
+                data: undefined,
+                variables: this.getOptions().variables
+            };
+        }
+        var currentResult = result;
+        if (this.refreshClient().isNew) {
+            currentResult = this.getLoadingResult();
+        }
+        var shouldResubscribe = this.getOptions().shouldResubscribe;
+        if (typeof shouldResubscribe === 'function') {
+            shouldResubscribe = !!shouldResubscribe(this.getOptions());
+        }
+        if (shouldResubscribe !== false &&
+            this.previousOptions &&
+            Object.keys(this.previousOptions).length > 0 &&
+            (this.previousOptions.subscription !== this.getOptions().subscription ||
+                !equality.equal(this.previousOptions.variables, this.getOptions().variables) ||
+                this.previousOptions.skip !== this.getOptions().skip)) {
+            this.cleanup();
+            currentResult = this.getLoadingResult();
+        }
+        this.initialize(this.getOptions());
+        this.startSubscription();
+        this.previousOptions = this.getOptions();
+        return tslib.__assign(tslib.__assign({}, currentResult), { variables: this.getOptions().variables });
+    };
+    SubscriptionData.prototype.afterExecute = function () {
+        this.isMounted = true;
+    };
+    SubscriptionData.prototype.cleanup = function () {
+        this.endSubscription();
+        delete this.currentObservable.query;
+    };
+    SubscriptionData.prototype.initialize = function (options) {
+        if (this.currentObservable.query || this.getOptions().skip === true)
+            return;
+        this.currentObservable.query = this.refreshClient().client.subscribe({
+            query: options.subscription,
+            variables: options.variables,
+            fetchPolicy: options.fetchPolicy,
+            context: options.context,
+        });
+    };
+    SubscriptionData.prototype.startSubscription = function () {
+        if (this.currentObservable.subscription)
+            return;
+        this.currentObservable.subscription = this.currentObservable.query.subscribe({
+            next: this.updateCurrentData.bind(this),
+            error: this.updateError.bind(this),
+            complete: this.completeSubscription.bind(this)
+        });
+    };
+    SubscriptionData.prototype.getLoadingResult = function () {
+        return {
+            loading: true,
+            error: undefined,
+            data: undefined
+        };
+    };
+    SubscriptionData.prototype.updateResult = function (result) {
+        if (this.isMounted) {
+            this.setResult(result);
+        }
+    };
+    SubscriptionData.prototype.updateCurrentData = function (result) {
+        var onSubscriptionData = this.getOptions().onSubscriptionData;
+        this.updateResult({
+            data: result.data,
+            loading: false,
+            error: undefined
+        });
+        if (onSubscriptionData) {
+            onSubscriptionData({
+                client: this.refreshClient().client,
+                subscriptionData: result
+            });
+        }
+    };
+    SubscriptionData.prototype.updateError = function (error) {
+        this.updateResult({
+            error: error,
+            loading: false
+        });
+    };
+    SubscriptionData.prototype.completeSubscription = function () {
+        var _this = this;
+        Promise.resolve().then(function () {
+            var onSubscriptionComplete = _this.getOptions().onSubscriptionComplete;
+            if (onSubscriptionComplete)
+                onSubscriptionComplete();
+            _this.endSubscription();
+        });
+    };
+    SubscriptionData.prototype.endSubscription = function () {
+        if (this.currentObservable.subscription) {
+            this.currentObservable.subscription.unsubscribe();
+            delete this.currentObservable.subscription;
+        }
+    };
+    return SubscriptionData;
+}(OperationData));
+
+var MutationData = (function (_super) {
+    tslib.__extends(MutationData, _super);
+    function MutationData(_a) {
+        var options = _a.options, context = _a.context, result = _a.result, setResult = _a.setResult;
+        var _this = _super.call(this, options, context) || this;
+        _this.runMutation = function (mutationFunctionOptions) {
+            if (mutationFunctionOptions === void 0) { mutationFunctionOptions = {}; }
+            _this.onMutationStart();
+            var mutationId = _this.generateNewMutationId();
+            return _this.mutate(mutationFunctionOptions)
+                .then(function (response) {
+                _this.onMutationCompleted(response, mutationId);
+                return response;
+            })
+                .catch(function (error) {
+                var onError = _this.getOptions().onError;
+                _this.onMutationError(error, mutationId);
+                if (onError) {
+                    onError(error);
+                    return {
+                        data: undefined,
+                        errors: error,
+                    };
+                }
+                else {
+                    throw error;
+                }
+            });
+        };
+        _this.verifyDocumentType(options.mutation, exports.DocumentType.Mutation);
+        _this.result = result;
+        _this.setResult = setResult;
+        _this.mostRecentMutationId = 0;
+        return _this;
+    }
+    MutationData.prototype.execute = function (result) {
+        this.isMounted = true;
+        this.verifyDocumentType(this.getOptions().mutation, exports.DocumentType.Mutation);
+        return [
+            this.runMutation,
+            tslib.__assign(tslib.__assign({}, result), { client: this.refreshClient().client })
+        ];
+    };
+    MutationData.prototype.afterExecute = function () {
+        this.isMounted = true;
+        return this.unmount.bind(this);
+    };
+    MutationData.prototype.cleanup = function () {
+    };
+    MutationData.prototype.mutate = function (options) {
+        return this.refreshClient().client.mutate(mergeOptions(this.getOptions(), options));
+    };
+    MutationData.prototype.onMutationStart = function () {
+        if (!this.result.loading && !this.getOptions().ignoreResults) {
+            this.updateResult({
+                loading: true,
+                error: undefined,
+                data: undefined,
+                called: true
+            });
+        }
+    };
+    MutationData.prototype.onMutationCompleted = function (response, mutationId) {
+        var _a = this.getOptions(), onCompleted = _a.onCompleted, ignoreResults = _a.ignoreResults;
+        var data = response.data, errors = response.errors;
+        var error = errors && errors.length > 0
+            ? new ApolloError({ graphQLErrors: errors })
+            : undefined;
+        var callOncomplete = function () {
+            return onCompleted ? onCompleted(data) : null;
+        };
+        if (this.isMostRecentMutation(mutationId) && !ignoreResults) {
+            this.updateResult({
+                called: true,
+                loading: false,
+                data: data,
+                error: error
+            });
+        }
+        callOncomplete();
+    };
+    MutationData.prototype.onMutationError = function (error, mutationId) {
+        if (this.isMostRecentMutation(mutationId)) {
+            this.updateResult({
+                loading: false,
+                error: error,
+                data: undefined,
+                called: true
+            });
+        }
+    };
+    MutationData.prototype.generateNewMutationId = function () {
+        return ++this.mostRecentMutationId;
+    };
+    MutationData.prototype.isMostRecentMutation = function (mutationId) {
+        return this.mostRecentMutationId === mutationId;
+    };
+    MutationData.prototype.updateResult = function (result) {
+        if (this.isMounted &&
+            (!this.previousResult || !equality.equal(this.previousResult, result))) {
+            this.setResult(result);
+            this.previousResult = result;
+            return result;
+        }
+    };
+    return MutationData;
+}(OperationData));
+
+var QueryData = (function (_super) {
+    tslib.__extends(QueryData, _super);
+    function QueryData(_a) {
+        var options = _a.options, context = _a.context, onNewData = _a.onNewData;
+        var _this = _super.call(this, options, context) || this;
+        _this.runLazy = false;
+        _this.previous = Object.create(null);
+        _this.runLazyQuery = function (options) {
+            _this.cleanup();
+            _this.runLazy = true;
+            _this.lazyOptions = options;
+            _this.onNewData();
+        };
+        _this.obsRefetch = function (variables) { var _a; return (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.refetch(variables); };
+        _this.obsFetchMore = function (fetchMoreOptions) { var _a; return (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.fetchMore(fetchMoreOptions); };
+        _this.obsUpdateQuery = function (mapFn) { var _a; return (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.updateQuery(mapFn); };
+        _this.obsStartPolling = function (pollInterval) {
+            var _a;
+            (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.startPolling(pollInterval);
+        };
+        _this.obsStopPolling = function () {
+            var _a;
+            (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.stopPolling();
+        };
+        _this.obsSubscribeToMore = function (options) { var _a; return (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.subscribeToMore(options); };
+        _this.onNewData = onNewData;
+        return _this;
+    }
+    QueryData.prototype.execute = function () {
+        this.refreshClient();
+        var _a = this.getOptions(), skip = _a.skip, query = _a.query;
+        if (skip || query !== this.previous.query) {
+            this.removeQuerySubscription();
+            this.removeObservable(!skip);
+            this.previous.query = query;
+        }
+        this.updateObservableQuery();
+        return this.getExecuteSsrResult() || this.getExecuteResult();
+    };
+    QueryData.prototype.executeLazy = function () {
+        return !this.runLazy
+            ? [
+                this.runLazyQuery,
+                {
+                    loading: false,
+                    networkStatus: exports.NetworkStatus.ready,
+                    called: false,
+                    data: undefined
+                }
+            ]
+            : [this.runLazyQuery, this.execute()];
+    };
+    QueryData.prototype.fetchData = function () {
+        var _this = this;
+        var options = this.getOptions();
+        if (options.skip || options.ssr === false)
+            return false;
+        return new Promise(function (resolve) { return _this.startQuerySubscription(resolve); });
+    };
+    QueryData.prototype.afterExecute = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.lazy, lazy = _c === void 0 ? false : _c;
+        this.isMounted = true;
+        var options = this.getOptions();
+        if (this.currentObservable &&
+            !this.ssrInitiated() &&
+            !this.client.disableNetworkFetches) {
+            this.startQuerySubscription();
+        }
+        if (!lazy || this.runLazy) {
+            this.handleErrorOrCompleted();
+        }
+        this.previousOptions = options;
+        return this.unmount.bind(this);
+    };
+    QueryData.prototype.cleanup = function () {
+        this.removeQuerySubscription();
+        this.removeObservable(true);
+        delete this.previous.result;
+    };
+    QueryData.prototype.getOptions = function () {
+        var options = _super.prototype.getOptions.call(this);
+        if (this.lazyOptions) {
+            options.variables = tslib.__assign(tslib.__assign({}, options.variables), this.lazyOptions.variables);
+            options.context = tslib.__assign(tslib.__assign({}, options.context), this.lazyOptions.context);
+        }
+        if (this.runLazy) {
+            delete options.skip;
+        }
+        return options;
+    };
+    QueryData.prototype.ssrInitiated = function () {
+        return this.context && this.context.renderPromises;
+    };
+    QueryData.prototype.getExecuteSsrResult = function () {
+        var _a = this.getOptions(), ssr = _a.ssr, skip = _a.skip;
+        var ssrDisabled = ssr === false;
+        var fetchDisabled = this.refreshClient().client.disableNetworkFetches;
+        var ssrLoading = tslib.__assign({ loading: true, networkStatus: exports.NetworkStatus.loading, called: true, data: undefined, stale: false, client: this.client }, this.observableQueryFields());
+        if (ssrDisabled && (this.ssrInitiated() || fetchDisabled)) {
+            this.previous.result = ssrLoading;
+            return ssrLoading;
+        }
+        if (this.ssrInitiated()) {
+            var result = this.getExecuteResult() || ssrLoading;
+            if (result.loading && !skip) {
+                this.context.renderPromises.addQueryPromise(this, function () { return null; });
+            }
+            return result;
+        }
+    };
+    QueryData.prototype.prepareObservableQueryOptions = function () {
+        var options = this.getOptions();
+        this.verifyDocumentType(options.query, exports.DocumentType.Query);
+        var displayName = options.displayName || 'Query';
+        if (this.ssrInitiated() &&
+            (options.fetchPolicy === 'network-only' ||
+                options.fetchPolicy === 'cache-and-network')) {
+            options.fetchPolicy = 'cache-first';
+        }
+        return tslib.__assign(tslib.__assign({}, options), { displayName: displayName, context: options.context });
+    };
+    QueryData.prototype.initializeObservableQuery = function () {
+        if (this.ssrInitiated()) {
+            this.currentObservable = this.context.renderPromises.getSSRObservable(this.getOptions());
+        }
+        if (!this.currentObservable) {
+            var observableQueryOptions = this.prepareObservableQueryOptions();
+            this.previous.observableQueryOptions = tslib.__assign(tslib.__assign({}, observableQueryOptions), { children: void 0 });
+            this.currentObservable = this.refreshClient().client.watchQuery(tslib.__assign({}, observableQueryOptions));
+            if (this.ssrInitiated()) {
+                this.context.renderPromises.registerSSRObservable(this.currentObservable, observableQueryOptions);
+            }
+        }
+    };
+    QueryData.prototype.updateObservableQuery = function () {
+        if (!this.currentObservable) {
+            this.initializeObservableQuery();
+            return;
+        }
+        var newObservableQueryOptions = tslib.__assign(tslib.__assign({}, this.prepareObservableQueryOptions()), { children: void 0 });
+        if (this.getOptions().skip) {
+            this.previous.observableQueryOptions = newObservableQueryOptions;
+            return;
+        }
+        if (!equality.equal(newObservableQueryOptions, this.previous.observableQueryOptions)) {
+            this.previous.observableQueryOptions = newObservableQueryOptions;
+            this.currentObservable
+                .setOptions(newObservableQueryOptions)
+                .catch(function () { });
+        }
+    };
+    QueryData.prototype.startQuerySubscription = function (onNewData) {
+        var _this = this;
+        if (onNewData === void 0) { onNewData = this.onNewData; }
+        if (this.currentSubscription || this.getOptions().skip)
+            return;
+        this.currentSubscription = this.currentObservable.subscribe({
+            next: function (_a) {
+                var loading = _a.loading, networkStatus = _a.networkStatus, data = _a.data;
+                var previousResult = _this.previous.result;
+                if (previousResult &&
+                    previousResult.loading === loading &&
+                    previousResult.networkStatus === networkStatus &&
+                    equality.equal(previousResult.data, data)) {
+                    return;
+                }
+                onNewData();
+            },
+            error: function (error) {
+                _this.resubscribeToQuery();
+                if (!error.hasOwnProperty('graphQLErrors'))
+                    throw error;
+                var previousResult = _this.previous.result;
+                if ((previousResult && previousResult.loading) ||
+                    !equality.equal(error, _this.previous.error)) {
+                    _this.previous.error = error;
+                    onNewData();
+                }
+            }
+        });
+    };
+    QueryData.prototype.resubscribeToQuery = function () {
+        this.removeQuerySubscription();
+        var currentObservable = this.currentObservable;
+        if (currentObservable) {
+            var lastError = currentObservable.getLastError();
+            var lastResult = currentObservable.getLastResult();
+            currentObservable.resetLastResults();
+            this.startQuerySubscription();
+            Object.assign(currentObservable, {
+                lastError: lastError,
+                lastResult: lastResult
+            });
+        }
+    };
+    QueryData.prototype.getExecuteResult = function () {
+        var result = this.observableQueryFields();
+        var options = this.getOptions();
+        if (options.skip) {
+            result = tslib.__assign(tslib.__assign({}, result), { data: undefined, error: undefined, loading: false, networkStatus: exports.NetworkStatus.ready, called: true });
+        }
+        else if (this.currentObservable) {
+            var currentResult = this.currentObservable.getCurrentResult();
+            var data = currentResult.data, loading = currentResult.loading, partial = currentResult.partial, networkStatus = currentResult.networkStatus, errors = currentResult.errors;
+            var error = currentResult.error;
+            if (errors && errors.length > 0) {
+                error = new ApolloError({ graphQLErrors: errors });
+            }
+            result = tslib.__assign(tslib.__assign({}, result), { data: data, loading: loading, networkStatus: networkStatus, error: error, called: true });
+            if (loading) ;
+            else if (error) {
+                Object.assign(result, {
+                    data: (this.currentObservable.getLastResult() || {})
+                        .data
+                });
+            }
+            else {
+                var fetchPolicy = this.currentObservable.options.fetchPolicy;
+                var partialRefetch = options.partialRefetch;
+                if (partialRefetch &&
+                    partial &&
+                    (!data || Object.keys(data).length === 0) &&
+                    fetchPolicy !== 'cache-only') {
+                    Object.assign(result, {
+                        loading: true,
+                        networkStatus: exports.NetworkStatus.loading
+                    });
+                    result.refetch();
+                    return result;
+                }
+            }
+        }
+        result.client = this.client;
+        this.setOptions(options, true);
+        var previousResult = this.previous.result;
+        this.previous.loading =
+            previousResult && previousResult.loading || false;
+        result.previousData = previousResult &&
+            (previousResult.data || previousResult.previousData);
+        this.previous.result = result;
+        this.currentObservable && this.currentObservable.resetQueryStoreErrors();
+        return result;
+    };
+    QueryData.prototype.handleErrorOrCompleted = function () {
+        if (!this.currentObservable || !this.previous.result)
+            return;
+        var _a = this.previous.result, data = _a.data, loading = _a.loading, error = _a.error;
+        if (!loading) {
+            var _b = this.getOptions(), query = _b.query, variables = _b.variables, onCompleted = _b.onCompleted, onError = _b.onError, skip = _b.skip;
+            if (this.previousOptions &&
+                !this.previous.loading &&
+                equality.equal(this.previousOptions.query, query) &&
+                equality.equal(this.previousOptions.variables, variables)) {
+                return;
+            }
+            if (onCompleted && !error && !skip) {
+                onCompleted(data);
+            }
+            else if (onError && error) {
+                onError(error);
+            }
+        }
+    };
+    QueryData.prototype.removeQuerySubscription = function () {
+        if (this.currentSubscription) {
+            this.currentSubscription.unsubscribe();
+            delete this.currentSubscription;
+        }
+    };
+    QueryData.prototype.removeObservable = function (andDelete) {
+        if (this.currentObservable) {
+            this.currentObservable["tearDownQuery"]();
+            if (andDelete) {
+                delete this.currentObservable;
+            }
+        }
+    };
+    QueryData.prototype.observableQueryFields = function () {
+        var _a;
+        return {
+            variables: (_a = this.currentObservable) === null || _a === void 0 ? void 0 : _a.variables,
+            refetch: this.obsRefetch,
+            fetchMore: this.obsFetchMore,
+            updateQuery: this.obsUpdateQuery,
+            startPolling: this.obsStartPolling,
+            stopPolling: this.obsStopPolling,
+            subscribeToMore: this.obsSubscribeToMore
+        };
+    };
+    return QueryData;
+}(OperationData));
+
+function useDeepMemo(memoFn, key) {
+    var ref = React.useRef();
+    if (!ref.current || !equality.equal(key, ref.current.key)) {
+        ref.current = { key: key, value: memoFn() };
+    }
+    return ref.current.value;
+}
+
+function useAfterFastRefresh(effectFn) {
+    if (__DEV__) {
+        var didRefresh_1 = React.useRef(false);
+        React.useEffect(function () {
+            return function () {
+                didRefresh_1.current = true;
+            };
+        }, []);
+        React.useEffect(function () {
+            if (didRefresh_1.current === true) {
+                didRefresh_1.current = false;
+                effectFn();
+            }
+        }, []);
+    }
+}
+
+function useBaseQuery(query, options, lazy) {
+    if (lazy === void 0) { lazy = false; }
+    var context = React.useContext(getApolloContext());
+    var _a = React.useReducer(function (x) { return x + 1; }, 0), tick = _a[0], forceUpdate = _a[1];
+    var updatedOptions = options ? tslib.__assign(tslib.__assign({}, options), { query: query }) : { query: query };
+    var queryDataRef = React.useRef();
+    var queryData = queryDataRef.current || (queryDataRef.current = new QueryData({
+        options: updatedOptions,
+        context: context,
+        onNewData: function () {
+            if (!queryData.ssrInitiated()) {
+                Promise.resolve().then(function () { return queryDataRef.current && queryDataRef.current.isMounted && forceUpdate(); });
+            }
+            else {
+                forceUpdate();
+            }
+        }
+    }));
+    queryData.setOptions(updatedOptions);
+    queryData.context = context;
+    var memo = {
+        options: tslib.__assign(tslib.__assign({}, updatedOptions), { onError: void 0, onCompleted: void 0 }),
+        context: context,
+        tick: tick
+    };
+    var result = useDeepMemo(function () { return (lazy ? queryData.executeLazy() : queryData.execute()); }, memo);
+    var queryResult = lazy
+        ? result[1]
+        : result;
+    if (__DEV__) {
+        useAfterFastRefresh(forceUpdate);
+    }
+    React.useEffect(function () {
+        return function () {
+            queryData.cleanup();
+            queryDataRef.current = void 0;
+        };
+    }, []);
+    React.useEffect(function () { return queryData.afterExecute({ lazy: lazy }); }, [
+        queryResult.loading,
+        queryResult.networkStatus,
+        queryResult.error,
+        queryResult.data,
+        queryData.currentObservable,
+    ]);
+    return result;
+}
+
+function useLazyQuery(query, options) {
+    return useBaseQuery(query, options, true);
+}
+
+function useMutation(mutation, options) {
+    var context = React.useContext(getApolloContext());
+    var _a = React.useState({ called: false, loading: false }), result = _a[0], setResult = _a[1];
+    var updatedOptions = options ? tslib.__assign(tslib.__assign({}, options), { mutation: mutation }) : { mutation: mutation };
+    var mutationDataRef = React.useRef();
+    function getMutationDataRef() {
+        if (!mutationDataRef.current) {
+            mutationDataRef.current = new MutationData({
+                options: updatedOptions,
+                context: context,
+                result: result,
+                setResult: setResult
+            });
+        }
+        return mutationDataRef.current;
+    }
+    var mutationData = getMutationDataRef();
+    mutationData.setOptions(updatedOptions);
+    mutationData.context = context;
+    React.useEffect(function () { return mutationData.afterExecute(); });
+    return mutationData.execute(result);
+}
+
+function useQuery(query, options) {
+    return useBaseQuery(query, options, false);
+}
+
+function useSubscription(subscription, options) {
+    var _a = React.useReducer(function (x) { return x + 1; }, 0), forceUpdate = _a[1];
+    var context = React.useContext(getApolloContext());
+    var updatedOptions = options
+        ? tslib.__assign(tslib.__assign({}, options), { subscription: subscription }) : { subscription: subscription };
+    var _b = React.useState({
+        loading: !updatedOptions.skip,
+        error: void 0,
+        data: void 0,
+    }), result = _b[0], setResult = _b[1];
+    var subscriptionDataRef = React.useRef();
+    function getSubscriptionDataRef() {
+        if (!subscriptionDataRef.current) {
+            subscriptionDataRef.current = new SubscriptionData({
+                options: updatedOptions,
+                context: context,
+                setResult: setResult
+            });
+        }
+        return subscriptionDataRef.current;
+    }
+    var subscriptionData = getSubscriptionDataRef();
+    subscriptionData.setOptions(updatedOptions, true);
+    subscriptionData.context = context;
+    if (__DEV__) {
+        useAfterFastRefresh(forceUpdate);
+    }
+    React.useEffect(function () { return subscriptionData.afterExecute(); });
+    React.useEffect(function () {
+        return function () {
+            subscriptionData.cleanup();
+            subscriptionDataRef.current = void 0;
+        };
+    }, []);
+    return subscriptionData.execute(result);
+}
+
+function useReactiveVar(rv) {
+    var value = rv();
+    var setValue = React.useState(value)[1];
+    React.useEffect(function () {
+        var probablySameValue = rv();
+        if (value !== probablySameValue) {
+            setValue(probablySameValue);
+        }
+        else {
+            return rv.onNextChange(setValue);
+        }
+    }, [value]);
+    return value;
+}
 
 exports.setLogVerbosity = tsInvariant.setVerbosity;
 exports.Observable = zenObservableTs.Observable;
@@ -5700,8 +6560,10 @@ exports.gql = graphqlTag.gql;
 exports.resetCaches = graphqlTag.resetCaches;
 exports.ApolloCache = ApolloCache;
 exports.ApolloClient = ApolloClient;
+exports.ApolloConsumer = ApolloConsumer;
 exports.ApolloError = ApolloError;
 exports.ApolloLink = ApolloLink;
+exports.ApolloProvider = ApolloProvider;
 exports.HttpLink = HttpLink;
 exports.InMemoryCache = InMemoryCache;
 exports.MissingFieldError = MissingFieldError;
@@ -5718,12 +6580,16 @@ exports.fallbackHttpConfig = fallbackHttpConfig;
 exports.from = from;
 exports.fromError = fromError;
 exports.fromPromise = fromPromise;
+exports.getApolloContext = getApolloContext;
 exports.isApolloError = isApolloError;
 exports.isReference = isReference;
 exports.makeReference = makeReference;
 exports.makeVar = makeVar;
 exports.mergeOptions = mergeOptions;
+exports.operationName = operationName;
 exports.parseAndCheckHttpResponse = parseAndCheckHttpResponse;
+exports.parser = parser;
+exports.resetApolloContext = getApolloContext;
 exports.rewriteURIForGET = rewriteURIForGET;
 exports.selectHttpOptionsAndBody = selectHttpOptionsAndBody;
 exports.selectURI = selectURI;
@@ -5731,4 +6597,10 @@ exports.serializeFetchParameter = serializeFetchParameter;
 exports.split = split;
 exports.throwServerError = throwServerError;
 exports.toPromise = toPromise;
+exports.useApolloClient = useApolloClient;
+exports.useLazyQuery = useLazyQuery;
+exports.useMutation = useMutation;
+exports.useQuery = useQuery;
+exports.useReactiveVar = useReactiveVar;
+exports.useSubscription = useSubscription;
 //# sourceMappingURL=apollo-client.cjs.js.map