@apollo/client 3.5.10 → 3.6.4

package/react/hooks/hooks.cjs

@@ -3,16 +3,31 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var globals = require('../../utilities/globals');
-var react = require('react');
+var React = require('react');
 var context = require('../context');
 var tslib = require('tslib');
+var utilities = require('../../utilities');
 var equality = require('@wry/equality');
 var core = require('../../core');
 var errors = require('../../errors');
 var parser = require('../parser');
 
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        for (var k in e) {
+            n[k] = e[k];
+        }
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
 function useApolloClient(override) {
-    var context$1 = react.useContext(context.getApolloContext());
+    var context$1 = React.useContext(context.getApolloContext());
     var client = override || context$1.client;
     __DEV__ ? globals.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 ' +
@@ -20,254 +35,331 @@ function useApolloClient(override) {
     return client;
 }
 
-function useQuery(query, options) {
-    var _a;
-    var context$1 = react.useContext(context.getApolloContext());
-    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
-    var defaultWatchQueryOptions = client.defaultOptions.watchQuery;
-    parser.verifyDocumentType(query, parser.DocumentType.Query);
-    var _b = react.useState(function () {
-        var watchQueryOptions = createWatchQueryOptions(query, options, defaultWatchQueryOptions);
-        var obsQuery = null;
-        if (context$1.renderPromises) {
-            obsQuery = context$1.renderPromises.getSSRObservable(watchQueryOptions);
-        }
-        if (!obsQuery) {
-            obsQuery = client.watchQuery(watchQueryOptions);
-            if (context$1.renderPromises) {
-                context$1.renderPromises.registerSSRObservable(obsQuery, watchQueryOptions);
+var didWarnUncachedGetSnapshot = false;
+var uSESKey = "useSyncExternalStore";
+var realHook = React__namespace[uSESKey];
+var useSyncExternalStore = realHook || (function (subscribe, getSnapshot, getServerSnapshot) {
+    var value = getSnapshot();
+    if (__DEV__ &&
+        !didWarnUncachedGetSnapshot &&
+        value !== getSnapshot()) {
+        didWarnUncachedGetSnapshot = true;
+        __DEV__ && globals.invariant.error('The result of getSnapshot should be cached to avoid an infinite loop');
+    }
+    var _a = React__namespace.useState({ inst: { value: value, getSnapshot: getSnapshot } }), inst = _a[0].inst, forceUpdate = _a[1];
+    if (utilities.canUseLayoutEffect) {
+        React__namespace.useLayoutEffect(function () {
+            Object.assign(inst, { value: value, getSnapshot: getSnapshot });
+            if (checkIfSnapshotChanged(inst)) {
+                forceUpdate({ inst: inst });
             }
+        }, [subscribe, value, getSnapshot]);
+    }
+    else {
+        Object.assign(inst, { value: value, getSnapshot: getSnapshot });
+    }
+    React__namespace.useEffect(function () {
+        if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({ inst: inst });
         }
-        if (context$1.renderPromises &&
-            (options === null || options === void 0 ? void 0 : options.ssr) !== false &&
-            !(options === null || options === void 0 ? void 0 : options.skip) &&
-            obsQuery.getCurrentResult().loading) {
-            context$1.renderPromises.addQueryPromise({
-                getOptions: function () { return createWatchQueryOptions(query, options, defaultWatchQueryOptions); },
-                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();
-                        },
+        return subscribe(function handleStoreChange() {
+            if (checkIfSnapshotChanged(inst)) {
+                forceUpdate({ inst: inst });
+            }
+        });
+    }, [subscribe]);
+    return value;
+});
+function checkIfSnapshotChanged(_a) {
+    var value = _a.value, getSnapshot = _a.getSnapshot;
+    try {
+        return value !== getSnapshot();
+    }
+    catch (_b) {
+        return true;
+    }
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function useQuery(query, options) {
+    if (options === void 0) { options = Object.create(null); }
+    return useInternalState(useApolloClient(options.client), query).useQuery(options);
+}
+function useInternalState(client, query) {
+    var stateRef = React.useRef();
+    if (!stateRef.current ||
+        client !== stateRef.current.client ||
+        query !== stateRef.current.query) {
+        stateRef.current = new InternalState(client, query);
+    }
+    var state = stateRef.current;
+    var _a = React.useState(0); _a[0]; var setTick = _a[1];
+    state.forceUpdate = function () {
+        setTick(function (tick) { return tick + 1; });
+    };
+    return state;
+}
+var InternalState = (function () {
+    function InternalState(client, query) {
+        this.client = client;
+        this.query = query;
+        this.asyncResolveFns = new Set();
+        this.optionsToIgnoreOnce = new (utilities.canUseWeakSet ? WeakSet : Set)();
+        this.ssrDisabledResult = utilities.maybeDeepFreeze({
+            loading: true,
+            data: void 0,
+            error: void 0,
+            networkStatus: core.NetworkStatus.loading,
+        });
+        this.skipStandbyResult = utilities.maybeDeepFreeze({
+            loading: false,
+            data: void 0,
+            error: void 0,
+            networkStatus: core.NetworkStatus.ready,
+        });
+        this.toQueryResultCache = new (utilities.canUseWeakMap ? WeakMap : Map)();
+        parser.verifyDocumentType(query, parser.DocumentType.Query);
+    }
+    InternalState.prototype.forceUpdate = function () {
+        __DEV__ && globals.invariant.warn("Calling default no-op implementation of InternalState#forceUpdate");
+    };
+    InternalState.prototype.asyncUpdate = function () {
+        var _this = this;
+        return new Promise(function (resolve) {
+            _this.asyncResolveFns.add(resolve);
+            _this.optionsToIgnoreOnce.add(_this.watchQueryOptions);
+            _this.forceUpdate();
+        });
+    };
+    InternalState.prototype.useQuery = function (options) {
+        var _this = this;
+        this.renderPromises = React.useContext(context.getApolloContext()).renderPromises;
+        this.useOptions(options);
+        var obsQuery = this.useObservableQuery();
+        var result = useSyncExternalStore(React.useCallback(function () {
+            if (_this.renderPromises) {
+                return function () { };
+            }
+            var onNext = function () {
+                var previousResult = _this.result;
+                var result = obsQuery.getCurrentResult();
+                if (previousResult &&
+                    previousResult.loading === result.loading &&
+                    previousResult.networkStatus === result.networkStatus &&
+                    equality.equal(previousResult.data, result.data)) {
+                    return;
+                }
+                _this.setResult(result);
+            };
+            var onError = function (error) {
+                var last = obsQuery["last"];
+                subscription.unsubscribe();
+                try {
+                    obsQuery.resetLastResults();
+                    subscription = obsQuery.subscribe(onNext, onError);
+                }
+                finally {
+                    obsQuery["last"] = last;
+                }
+                if (!hasOwnProperty.call(error, 'graphQLErrors')) {
+                    throw error;
+                }
+                var previousResult = _this.result;
+                if (!previousResult ||
+                    (previousResult && previousResult.loading) ||
+                    !equality.equal(error, previousResult.error)) {
+                    _this.setResult({
+                        data: (previousResult && previousResult.data),
+                        error: error,
+                        loading: false,
+                        networkStatus: core.NetworkStatus.error,
                     });
-                }); },
-            }, function () { return null; });
+                }
+            };
+            var subscription = obsQuery.subscribe(onNext, onError);
+            return function () { return subscription.unsubscribe(); };
+        }, [
+            obsQuery,
+            this.renderPromises,
+            this.client.disableNetworkFetches,
+        ]), function () { return _this.getCurrentResult(); }, function () { return _this.getCurrentResult(); });
+        this.unsafeHandlePartialRefetch(result);
+        var queryResult = this.toQueryResult(result);
+        if (!queryResult.loading && this.asyncResolveFns.size) {
+            this.asyncResolveFns.forEach(function (resolve) { return resolve(queryResult); });
+            this.asyncResolveFns.clear();
         }
-        return 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);
-            }
-            else if (result.data) {
-                (_b = options.onCompleted) === null || _b === void 0 ? void 0 : _b.call(options, result.data);
+        return queryResult;
+    };
+    InternalState.prototype.useOptions = function (options) {
+        var _a;
+        var watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options);
+        var currentWatchQueryOptions = this.watchQueryOptions;
+        if (this.optionsToIgnoreOnce.has(currentWatchQueryOptions) ||
+            !equality.equal(watchQueryOptions, currentWatchQueryOptions)) {
+            this.watchQueryOptions = watchQueryOptions;
+            if (currentWatchQueryOptions && this.observable) {
+                this.optionsToIgnoreOnce.delete(currentWatchQueryOptions);
+                this.observable.reobserve(watchQueryOptions);
+                this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
+                this.result = void 0;
             }
         }
-        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, defaultWatchQueryOptions),
-    });
-    react.useEffect(function () {
-        var _a, _b;
-        var watchQueryOptions = createWatchQueryOptions(query, options, defaultWatchQueryOptions);
-        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();
+        this.onCompleted = options.onCompleted || InternalState.prototype.onCompleted;
+        this.onError = options.onError || InternalState.prototype.onError;
+        if ((this.renderPromises || this.client.disableNetworkFetches) &&
+            this.queryHookOptions.ssr === false &&
+            !this.queryHookOptions.skip) {
+            this.result = this.ssrDisabledResult;
         }
-        else if (!equality.equal(ref.current.watchQueryOptions, watchQueryOptions)) {
-            obsQuery.setOptions(watchQueryOptions).catch(function () { });
-            nextResult = obsQuery.getCurrentResult();
-            ref.current.watchQueryOptions = watchQueryOptions;
+        else if (this.queryHookOptions.skip ||
+            this.watchQueryOptions.fetchPolicy === 'standby') {
+            this.result = this.skipStandbyResult;
         }
-        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 (nextResult.error) {
-                    (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, nextResult.error);
-                }
-                else if (nextResult.data) {
-                    (_b = options.onCompleted) === null || _b === void 0 ? void 0 : _b.call(options, nextResult.data);
-                }
-            }
+        else if (this.result === this.ssrDisabledResult ||
+            this.result === this.skipStandbyResult) {
+            this.result = void 0;
         }
-        Object.assign(ref.current, { client: client, query: query });
-    }, [obsQuery, client, query, options]);
-    react.useEffect(function () {
-        if (context$1.renderPromises) {
-            return;
+    };
+    InternalState.prototype.createWatchQueryOptions = function (_a) {
+        var _b;
+        if (_a === void 0) { _a = {}; }
+        var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; _a.displayName; _a.defaultOptions; var otherOptions = tslib.__rest(_a, ["skip", "ssr", "onCompleted", "onError", "displayName", "defaultOptions"]);
+        var watchQueryOptions = Object.assign(otherOptions, { query: this.query });
+        if (this.renderPromises &&
+            (watchQueryOptions.fetchPolicy === 'network-only' ||
+                watchQueryOptions.fetchPolicy === 'cache-and-network')) {
+            watchQueryOptions.fetchPolicy = 'cache-first';
         }
-        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;
-            }
-            if (previousResult.data) {
-                ref.current.previousData = previousResult.data;
-            }
-            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);
-            }
+        if (!watchQueryOptions.variables) {
+            watchQueryOptions.variables = {};
         }
-        function onError(error) {
-            var _a, _b;
-            var last = obsQuery["last"];
-            subscription.unsubscribe();
-            try {
-                obsQuery.resetLastResults();
-                subscription = obsQuery.subscribe(onNext, onError);
-            }
-            finally {
-                obsQuery["last"] = last;
+        if (skip) {
+            var _c = watchQueryOptions.fetchPolicy, fetchPolicy = _c === void 0 ? this.getDefaultFetchPolicy() : _c, _d = watchQueryOptions.initialFetchPolicy, initialFetchPolicy = _d === void 0 ? fetchPolicy : _d;
+            Object.assign(watchQueryOptions, {
+                initialFetchPolicy: initialFetchPolicy,
+                fetchPolicy: 'standby',
+            });
+        }
+        else if (!watchQueryOptions.fetchPolicy) {
+            watchQueryOptions.fetchPolicy =
+                ((_b = this.observable) === null || _b === void 0 ? void 0 : _b.options.initialFetchPolicy) ||
+                    this.getDefaultFetchPolicy();
+        }
+        return watchQueryOptions;
+    };
+    InternalState.prototype.getDefaultFetchPolicy = function () {
+        var _a, _b;
+        return (((_a = this.queryHookOptions.defaultOptions) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||
+            ((_b = this.client.defaultOptions.watchQuery) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||
+            "cache-first");
+    };
+    InternalState.prototype.onCompleted = function (data) { };
+    InternalState.prototype.onError = function (error) { };
+    InternalState.prototype.useObservableQuery = function () {
+        var obsQuery = this.observable =
+            this.renderPromises
+                && this.renderPromises.getSSRObservable(this.watchQueryOptions)
+                || this.observable
+                || this.client.watchQuery(core.mergeOptions(this.queryHookOptions.defaultOptions, this.watchQueryOptions));
+        this.obsQueryFields = React.useMemo(function () { return ({
+            refetch: obsQuery.refetch.bind(obsQuery),
+            reobserve: obsQuery.reobserve.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]);
+        var ssrAllowed = !(this.queryHookOptions.ssr === false ||
+            this.queryHookOptions.skip);
+        if (this.renderPromises && ssrAllowed) {
+            this.renderPromises.registerSSRObservable(obsQuery);
+            if (obsQuery.getCurrentResult().loading) {
+                this.renderPromises.addObservableQueryPromise(obsQuery);
             }
-            if (!error.hasOwnProperty('graphQLErrors')) {
-                throw error;
+        }
+        return obsQuery;
+    };
+    InternalState.prototype.setResult = function (nextResult) {
+        var previousResult = this.result;
+        if (previousResult && previousResult.data) {
+            this.previousData = previousResult.data;
+        }
+        this.result = nextResult;
+        this.forceUpdate();
+        this.handleErrorOrCompleted(nextResult);
+    };
+    InternalState.prototype.handleErrorOrCompleted = function (result) {
+        if (!result.loading) {
+            if (result.error) {
+                this.onError(result.error);
             }
-            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: core.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);
+            else if (result.data) {
+                this.onCompleted(result.data);
             }
         }
-        return function () { return subscription.unsubscribe(); };
-    }, [obsQuery, context$1.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) &&
+    };
+    InternalState.prototype.getCurrentResult = function () {
+        if (!this.result) {
+            this.handleErrorOrCompleted(this.result = this.observable.getCurrentResult());
+        }
+        return this.result;
+    };
+    InternalState.prototype.toQueryResult = function (result) {
+        var queryResult = this.toQueryResultCache.get(result);
+        if (queryResult)
+            return queryResult;
+        var data = result.data; result.partial; var resultWithoutPartial = tslib.__rest(result, ["data", "partial"]);
+        this.toQueryResultCache.set(result, queryResult = tslib.__assign(tslib.__assign(tslib.__assign({ data: data }, resultWithoutPartial), this.obsQueryFields), { client: this.client, observable: this.observable, variables: this.observable.variables, called: true, previousData: this.previousData }));
+        if (!queryResult.error && utilities.isNonEmptyArray(result.errors)) {
+            queryResult.error = new errors.ApolloError({ graphQLErrors: result.errors });
+        }
+        return queryResult;
+    };
+    InternalState.prototype.unsafeHandlePartialRefetch = function (result) {
+        if (result.partial &&
+            this.queryHookOptions.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: core.NetworkStatus.refetch });
-            obsQuery.refetch();
-        }
-        if (context$1.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, defaultWatchQueryOptions)).catch(function () { });
+            this.observable.options.fetchPolicy !== 'cache-only') {
+            Object.assign(result, {
+                loading: true,
+                networkStatus: core.NetworkStatus.refetch,
+            });
+            this.observable.refetch();
         }
-        Object.assign(ref.current, { options: options });
-    }
-    if ((context$1.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: core.NetworkStatus.loading,
-        };
-    }
-    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: core.NetworkStatus.ready,
-        };
-    }
-    if (result.errors && result.errors.length) {
-        result = tslib.__assign(tslib.__assign({}, result), { error: result.error || new errors.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, defaultWatchQueryOptions).variables, client: client, called: true, previousData: ref.current.previousData }), result);
-}
-function createWatchQueryOptions(query, options, defaultOptions) {
-    var _a;
-    if (options === void 0) { options = {}; }
-    var skip = options.skip; options.ssr; options.onCompleted; options.onError; options.displayName; var otherOptions = tslib.__rest(options, ["skip", "ssr", "onCompleted", "onError", "displayName"]);
-    var watchQueryOptions = tslib.__assign({ query: query }, otherOptions);
-    if (defaultOptions) {
-        watchQueryOptions = core.mergeOptions(defaultOptions, watchQueryOptions);
-    }
-    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 watchQueryOptions;
-}
+    };
+    return InternalState;
+}());
 
 var EAGER_METHODS = [
     'refetch',
+    'reobserve',
     'fetchMore',
     'updateQuery',
     'startPolling',
     'subscribeToMore',
 ];
 function useLazyQuery(query, options) {
-    var _a = react.useState({
-        called: false,
-    }), execution = _a[0], setExecution = _a[1];
-    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 }));
-    if (!execution.called) {
-        result = tslib.__assign(tslib.__assign({}, result), { loading: false, data: void 0, error: void 0, called: false });
-    }
-    var eagerMethods = react.useMemo(function () {
+    var internalState = useInternalState(useApolloClient(options && options.client), query);
+    var execOptionsRef = React.useRef();
+    var useQueryResult = internalState.useQuery(tslib.__assign(tslib.__assign(tslib.__assign({}, options), execOptionsRef.current), { skip: !execOptionsRef.current }));
+    var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||
+        internalState.getDefaultFetchPolicy();
+    var result = Object.assign(useQueryResult, {
+        called: !!execOptionsRef.current,
+    });
+    var eagerMethods = React.useMemo(function () {
         var eagerMethods = {};
         var _loop_1 = function (key) {
             var method = result[key];
             eagerMethods[key] = function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
+                if (!execOptionsRef.current) {
+                    execOptionsRef.current = Object.create(null);
+                    internalState.forceUpdate();
                 }
-                setExecution(function (execution) { return (tslib.__assign(tslib.__assign({}, execution), { called: true })); });
-                return method.apply(void 0, args);
+                return method.apply(this, arguments);
             };
         };
         for (var _i = 0, EAGER_METHODS_1 = EAGER_METHODS; _i < EAGER_METHODS_1.length; _i++) {
@@ -276,15 +368,14 @@ function useLazyQuery(query, options) {
         }
         return eagerMethods;
     }, []);
-    result.error = result.error || void 0;
     Object.assign(result, eagerMethods);
-    var execute = react.useCallback(function (executeOptions) {
-        setExecution({ called: true, options: executeOptions });
-        var promise = result.refetch(executeOptions === null || executeOptions === void 0 ? void 0 : executeOptions.variables).then(function (result1) {
-            var result2 = tslib.__assign(tslib.__assign({}, result), { data: result1.data, error: result1.error, called: true, loading: false });
-            Object.assign(result2, eagerMethods);
-            return result2;
-        });
+    var execute = React.useCallback(function (executeOptions) {
+        execOptionsRef.current = executeOptions ? tslib.__assign(tslib.__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
+            fetchPolicy: initialFetchPolicy,
+        };
+        var promise = internalState
+            .asyncUpdate()
+            .then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
         promise.catch(function () { });
         return promise;
     }, []);
@@ -294,12 +385,12 @@ function useLazyQuery(query, options) {
 function useMutation(mutation, options) {
     var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
     parser.verifyDocumentType(mutation, parser.DocumentType.Mutation);
-    var _a = react.useState({
+    var _a = React.useState({
         called: false,
         loading: false,
         client: client,
     }), result = _a[0], setResult = _a[1];
-    var ref = react.useRef({
+    var ref = React.useRef({
         result: result,
         mutationId: 0,
         isMounted: true,
@@ -310,7 +401,7 @@ function useMutation(mutation, options) {
     {
         Object.assign(ref.current, { client: client, options: options, mutation: mutation });
     }
-    var execute = react.useCallback(function (executeOptions) {
+    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 });
@@ -370,25 +461,28 @@ function useMutation(mutation, options) {
             throw error;
         });
     }, []);
-    var reset = react.useCallback(function () {
+    var reset = React.useCallback(function () {
         setResult({ called: false, loading: false, client: client });
     }, []);
-    react.useEffect(function () { return function () {
-        ref.current.isMounted = false;
-    }; }, []);
+    React.useEffect(function () {
+        ref.current.isMounted = true;
+        return function () {
+            ref.current.isMounted = false;
+        };
+    }, []);
     return [execute, tslib.__assign({ reset: reset }, result)];
 }
 
 function useSubscription(subscription, options) {
     var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
     parser.verifyDocumentType(subscription, parser.DocumentType.Subscription);
-    var _a = react.useState({
+    var _a = React.useState({
         loading: !(options === null || options === void 0 ? void 0 : options.skip),
         error: void 0,
         data: void 0,
         variables: options === null || options === void 0 ? void 0 : options.variables,
     }), result = _a[0], setResult = _a[1];
-    var _b = react.useState(function () {
+    var _b = React.useState(function () {
         if (options === null || options === void 0 ? void 0 : options.skip) {
             return null;
         }
@@ -399,15 +493,21 @@ function useSubscription(subscription, options) {
             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 canResetObservableRef = React.useRef(false);
+    React.useEffect(function () {
+        return function () {
+            canResetObservableRef.current = true;
+        };
+    }, []);
+    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) {
-            if (!(options === null || options === void 0 ? void 0 : options.skip) !== !((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.skip)) {
+            if (!(options === null || options === void 0 ? void 0 : options.skip) !== !((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.skip) || canResetObservableRef.current) {
                 setResult({
                     loading: false,
                     data: void 0,
@@ -415,13 +515,16 @@ function useSubscription(subscription, options) {
                     variables: options === null || options === void 0 ? void 0 : options.variables,
                 });
                 setObservable(null);
+                canResetObservableRef.current = false;
             }
         }
-        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))) {
+        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))) ||
+            canResetObservableRef.current) {
             setResult({
                 loading: true,
                 data: void 0,
@@ -434,10 +537,11 @@ function useSubscription(subscription, options) {
                 fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
                 context: options === null || options === void 0 ? void 0 : options.context,
             }));
+            canResetObservableRef.current = false;
         }
         Object.assign(ref.current, { client: client, subscription: subscription, options: options });
-    }, [client, subscription, options]);
-    react.useEffect(function () {
+    }, [client, subscription, options, canResetObservableRef.current]);
+    React.useEffect(function () {
         if (!observable) {
             return;
         }
@@ -478,8 +582,8 @@ function useSubscription(subscription, options) {
 
 function useReactiveVar(rv) {
     var value = rv();
-    var setValue = react.useState(value)[1];
-    react.useEffect(function () {
+    var setValue = React.useState(value)[1];
+    React.useEffect(function () {
         var probablySameValue = rv();
         if (value !== probablySameValue) {
             setValue(probablySameValue);