@apollo/client 3.10.8 → 3.11.0-rc.0

package/react/hooks/hooks.cjs

@@ -49,7 +49,7 @@ var useSyncExternalStore = realHook$1 ||
             !didWarnUncachedGetSnapshot &&
             value !== getSnapshot()) {
             didWarnUncachedGetSnapshot = true;
-            globalThis.__DEV__ !== false && globals.invariant.error(58);
+            globalThis.__DEV__ !== false && globals.invariant.error(59);
         }
         var _a = React__namespace.useState({
             inst: { value: value, getSnapshot: getSnapshot },
@@ -98,7 +98,7 @@ function useDeepMemo(memoFn, deps) {
 var useIsomorphicLayoutEffect = utilities.canUseDOM ? React__namespace.useLayoutEffect : React__namespace.useEffect;
 
 var Ctx;
-function noop() { }
+function noop$1() { }
 function useRenderGuard() {
     if (!Ctx) {
         Ctx = React__namespace.createContext(null);
@@ -107,7 +107,7 @@ function useRenderGuard() {
  function () {
         var orig = console.error;
         try {
-            console.error = noop;
+            console.error = noop$1;
             React__namespace["useContext" ](Ctx);
             return true;
         }
@@ -153,181 +153,185 @@ function wrapHook(hookName, useHook, clientOrObsQuery) {
 }
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
+var originalResult = Symbol();
+function noop() { }
+var lastWatchOptions = Symbol();
 function useQuery(query, options) {
     if (options === void 0) { options = Object.create(null); }
     return wrapHook("useQuery", _useQuery, useApolloClient(options && options.client))(query, options);
 }
 function _useQuery(query, options) {
-    return useInternalState(useApolloClient(options.client), query).useQuery(options);
+    var _a = useQueryInternals(query, options), result = _a.result, obsQueryFields = _a.obsQueryFields;
+    return React__namespace.useMemo(function () { return (tslib.__assign(tslib.__assign({}, result), obsQueryFields)); }, [result, obsQueryFields]);
 }
-function useInternalState(client, query) {
-    var forceUpdateState = React__namespace.useReducer(function (tick) { return tick + 1; }, 0)[1];
+function useInternalState(client, query, options, renderPromises, makeWatchQueryOptions) {
     function createInternalState(previous) {
-        return Object.assign(new InternalState(client, query, previous), {
-            forceUpdateState: forceUpdateState,
-        });
+        var _a;
+        parser.verifyDocumentType(query, parser.DocumentType.Query);
+        var internalState = {
+            client: client,
+            query: query,
+            observable:
+            (renderPromises &&
+                renderPromises.getSSRObservable(makeWatchQueryOptions())) ||
+                client.watchQuery(getObsQueryOptions(void 0, client, options, makeWatchQueryOptions())),
+            resultData: {
+                previousData: (_a = previous === null || previous === void 0 ? void 0 : previous.resultData.current) === null || _a === void 0 ? void 0 : _a.data,
+            },
+        };
+        return internalState;
     }
-    var _a = React__namespace.useState(createInternalState), state = _a[0], updateState = _a[1];
-    if (client !== state.client || query !== state.query) {
-        updateState((state = createInternalState(state)));
+    var _a = React__namespace.useState(createInternalState), internalState = _a[0], updateInternalState = _a[1];
+    function onQueryExecuted(watchQueryOptions) {
+        var _a;
+        var _b;
+        Object.assign(internalState.observable, (_a = {},
+            _a[lastWatchOptions] = watchQueryOptions,
+            _a));
+        var resultData = internalState.resultData;
+        updateInternalState(tslib.__assign(tslib.__assign({}, internalState), {
+            query: watchQueryOptions.query, resultData: Object.assign(resultData, {
+                previousData: ((_b = resultData.current) === null || _b === void 0 ? void 0 : _b.data) || resultData.previousData,
+                current: undefined,
+            }) }));
     }
-    return state;
-}
-var InternalState =  (function () {
-    function InternalState(client, query, previous) {
-        var _this = this;
-        this.client = client;
-        this.query = query;
-        this.forceUpdate = function () { return _this.forceUpdateState(); };
-        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);
-        var previousResult = previous && previous.result;
-        var previousData = previousResult && previousResult.data;
-        if (previousData) {
-            this.previousData = previousData;
-        }
+    if (client !== internalState.client || query !== internalState.query) {
+        var newInternalState = createInternalState(internalState);
+        updateInternalState(newInternalState);
+        return [newInternalState, onQueryExecuted];
     }
-    InternalState.prototype.forceUpdateState = function () {
-        globalThis.__DEV__ !== false && globals.invariant.warn(51);
+    return [internalState, onQueryExecuted];
+}
+function useQueryInternals(query, options) {
+    var client = useApolloClient(options.client);
+    var renderPromises = React__namespace.useContext(context.getApolloContext()).renderPromises;
+    var isSyncSSR = !!renderPromises;
+    var disableNetworkFetches = client.disableNetworkFetches;
+    var ssrAllowed = options.ssr !== false && !options.skip;
+    var partialRefetch = options.partialRefetch;
+    var makeWatchQueryOptions = createMakeWatchQueryOptions(client, query, options, isSyncSSR);
+    var _a = useInternalState(client, query, options, renderPromises, makeWatchQueryOptions), _b = _a[0], observable = _b.observable, resultData = _b.resultData, onQueryExecuted = _a[1];
+    var watchQueryOptions = makeWatchQueryOptions(observable);
+    useResubscribeIfNecessary(resultData,
+    observable,
+    client, options, watchQueryOptions);
+    var obsQueryFields = React__namespace.useMemo(function () { return bindObservableMethods(observable); }, [observable]);
+    useHandleSkip(resultData,
+    observable, client, options, watchQueryOptions, disableNetworkFetches, isSyncSSR);
+    useRegisterSSRObservable(observable, renderPromises, ssrAllowed);
+    var result = useObservableSubscriptionResult(resultData, observable, client, disableNetworkFetches, partialRefetch, isSyncSSR, {
+        onCompleted: options.onCompleted || noop,
+        onError: options.onError || noop,
+    });
+    return {
+        result: result,
+        obsQueryFields: obsQueryFields,
+        observable: observable,
+        resultData: resultData,
+        client: client,
+        onQueryExecuted: onQueryExecuted,
     };
-    InternalState.prototype.executeQuery = function (options) {
-        var _this = this;
-        var _a;
-        if (options.query) {
-            Object.assign(this, { query: options.query });
+}
+function useObservableSubscriptionResult(resultData, observable, client, disableNetworkFetches, partialRefetch, skipSubscribing, callbacks) {
+    var callbackRef = React__namespace.useRef(callbacks);
+    React__namespace.useEffect(function () {
+        callbackRef.current = callbacks;
+    });
+    return useSyncExternalStore(React__namespace.useCallback(function (handleStoreChange) {
+        if (skipSubscribing) {
+            return function () { };
         }
-        this.watchQueryOptions = this.createWatchQueryOptions((this.queryHookOptions = options));
-        var concast = this.observable.reobserveAsConcast(this.getObsQueryOptions());
-        this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
-        this.result = void 0;
-        this.forceUpdate();
-        return new Promise(function (resolve) {
-            var result;
-            concast.subscribe({
-                next: function (value) {
-                    result = value;
-                },
-                error: function () {
-                    resolve(_this.toQueryResult(_this.observable.getCurrentResult()));
-                },
-                complete: function () {
-                    resolve(_this.toQueryResult(result));
-                },
-            });
-        });
-    };
-    InternalState.prototype.useQuery = function (options) {
-        var _this = this;
-        this.renderPromises = React__namespace.useContext(context.getApolloContext()).renderPromises;
-        this.useOptions(options);
-        var obsQuery = this.useObservableQuery();
-        var result = useSyncExternalStore(
-        React__namespace.useCallback(function (handleStoreChange) {
-            if (_this.renderPromises) {
-                return function () { };
+        var onNext = function () {
+            var previousResult = resultData.current;
+            var result = observable.getCurrentResult();
+            if (previousResult &&
+                previousResult.loading === result.loading &&
+                previousResult.networkStatus === result.networkStatus &&
+                equal.equal(previousResult.data, result.data)) {
+                return;
             }
-            _this.forceUpdate = handleStoreChange;
-            var onNext = function () {
-                var previousResult = _this.result;
-                var result = obsQuery.getCurrentResult();
-                if (previousResult &&
-                    previousResult.loading === result.loading &&
-                    previousResult.networkStatus === result.networkStatus &&
-                    equal.equal(previousResult.data, result.data)) {
-                    return;
-                }
-                _this.setResult(result);
-            };
-            var onError = function (error) {
-                subscription.unsubscribe();
-                subscription = obsQuery.resubscribeAfterError(onNext, onError);
-                if (!hasOwnProperty.call(error, "graphQLErrors")) {
-                    throw error;
-                }
-                var previousResult = _this.result;
-                if (!previousResult ||
-                    (previousResult && previousResult.loading) ||
-                    !equal.equal(error, previousResult.error)) {
-                    _this.setResult({
-                        data: (previousResult && previousResult.data),
-                        error: error,
-                        loading: false,
-                        networkStatus: core.NetworkStatus.error,
-                    });
-                }
-            };
-            var subscription = obsQuery.subscribe(onNext, onError);
-            return function () {
-                setTimeout(function () { return subscription.unsubscribe(); });
-                _this.forceUpdate = function () { return _this.forceUpdateState(); };
-            };
-        }, [
-            obsQuery,
-            this.renderPromises,
-            this.client.disableNetworkFetches,
-        ]), function () { return _this.getCurrentResult(); }, function () { return _this.getCurrentResult(); });
-        this.unsafeHandlePartialRefetch(result);
-        return this.toQueryResult(result);
-    };
-    InternalState.prototype.useOptions = function (options) {
-        var _a;
-        var watchQueryOptions = this.createWatchQueryOptions((this.queryHookOptions = options));
-        var currentWatchQueryOptions = this.watchQueryOptions;
-        if (!equal.equal(watchQueryOptions, currentWatchQueryOptions)) {
-            this.watchQueryOptions = watchQueryOptions;
-            if (currentWatchQueryOptions && this.observable) {
-                this.observable.reobserve(this.getObsQueryOptions());
-                this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
-                this.result = void 0;
+            setResult(result, resultData, observable, client, partialRefetch, handleStoreChange, callbackRef.current);
+        };
+        var onError = function (error) {
+            subscription.current.unsubscribe();
+            subscription.current = observable.resubscribeAfterError(onNext, onError);
+            if (!hasOwnProperty.call(error, "graphQLErrors")) {
+                throw error;
             }
+            var previousResult = resultData.current;
+            if (!previousResult ||
+                (previousResult && previousResult.loading) ||
+                !equal.equal(error, previousResult.error)) {
+                setResult({
+                    data: (previousResult && previousResult.data),
+                    error: error,
+                    loading: false,
+                    networkStatus: core.NetworkStatus.error,
+                }, resultData, observable, client, partialRefetch, handleStoreChange, callbackRef.current);
+            }
+        };
+        var subscription = { current: observable.subscribe(onNext, onError) };
+        return function () {
+            setTimeout(function () { return subscription.current.unsubscribe(); });
+        };
+    }, [
+        disableNetworkFetches,
+        skipSubscribing,
+        observable,
+        resultData,
+        partialRefetch,
+        client,
+    ]), function () {
+        return getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);
+    }, function () {
+        return getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);
+    });
+}
+function useRegisterSSRObservable(observable, renderPromises, ssrAllowed) {
+    if (renderPromises && ssrAllowed) {
+        renderPromises.registerSSRObservable(observable);
+        if (observable.getCurrentResult().loading) {
+            renderPromises.addObservableQueryPromise(observable);
         }
-        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 (this.queryHookOptions.skip ||
-            this.watchQueryOptions.fetchPolicy === "standby") {
-            this.result = this.skipStandbyResult;
-        }
-        else if (this.result === this.ssrDisabledResult ||
-            this.result === this.skipStandbyResult) {
-            this.result = void 0;
-        }
-    };
-    InternalState.prototype.getObsQueryOptions = function () {
-        var toMerge = [];
-        var globalDefaults = this.client.defaultOptions.watchQuery;
-        if (globalDefaults)
-            toMerge.push(globalDefaults);
-        if (this.queryHookOptions.defaultOptions) {
-            toMerge.push(this.queryHookOptions.defaultOptions);
-        }
-        toMerge.push(utilities.compact(this.observable && this.observable.options, this.watchQueryOptions));
-        return toMerge.reduce(utilities.mergeOptions);
-    };
-    InternalState.prototype.createWatchQueryOptions = function (_a) {
-        var _b;
-        if (_a === void 0) { _a = {}; }
-        var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; _a.defaultOptions;
-        var otherOptions = tslib.__rest(_a, ["skip", "ssr", "onCompleted", "onError", "defaultOptions"]);
-        var watchQueryOptions = Object.assign(otherOptions, { query: this.query });
-        if (this.renderPromises &&
+    }
+}
+function useHandleSkip(
+resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, isSyncSSR) {
+    if ((isSyncSSR || disableNetworkFetches) &&
+        options.ssr === false &&
+        !options.skip) {
+        resultData.current = toQueryResult(ssrDisabledResult, resultData.previousData, observable, client);
+    }
+    else if (options.skip || watchQueryOptions.fetchPolicy === "standby") {
+        resultData.current = toQueryResult(skipStandbyResult, resultData.previousData, observable, client);
+    }
+    else if (
+    resultData.current &&
+        (resultData.current[originalResult] === ssrDisabledResult ||
+            resultData.current[originalResult] === skipStandbyResult)) {
+        resultData.current = void 0;
+    }
+}
+function useResubscribeIfNecessary(
+resultData,
+observable, client, options, watchQueryOptions) {
+    var _a;
+    if (observable[lastWatchOptions] &&
+        !equal.equal(observable[lastWatchOptions], watchQueryOptions)) {
+        observable.reobserve(getObsQueryOptions(observable, client, options, watchQueryOptions));
+        resultData.previousData =
+            ((_a = resultData.current) === null || _a === void 0 ? void 0 : _a.data) || resultData.previousData;
+        resultData.current = void 0;
+    }
+    observable[lastWatchOptions] = watchQueryOptions;
+}
+function createMakeWatchQueryOptions(client, query, _a, isSyncSSR) {
+    if (_a === void 0) { _a = {}; }
+    var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; var defaultOptions = _a.defaultOptions,
+    otherOptions = tslib.__rest(_a, ["skip", "ssr", "onCompleted", "onError", "defaultOptions"]);
+    return function (observable) {
+        var watchQueryOptions = Object.assign(otherOptions, { query: query });
+        if (isSyncSSR &&
             (watchQueryOptions.fetchPolicy === "network-only" ||
                 watchQueryOptions.fetchPolicy === "cache-and-network")) {
             watchQueryOptions.fetchPolicy = "cache-first";
@@ -336,117 +340,119 @@ var InternalState =  (function () {
             watchQueryOptions.variables = {};
         }
         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",
-            });
+            watchQueryOptions.initialFetchPolicy =
+                watchQueryOptions.initialFetchPolicy ||
+                    watchQueryOptions.fetchPolicy ||
+                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);
+            watchQueryOptions.fetchPolicy = "standby";
         }
         else if (!watchQueryOptions.fetchPolicy) {
             watchQueryOptions.fetchPolicy =
-                ((_b = this.observable) === null || _b === void 0 ? void 0 : _b.options.initialFetchPolicy) ||
-                    this.getDefaultFetchPolicy();
+                (observable === null || observable === void 0 ? void 0 : observable.options.initialFetchPolicy) ||
+                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);
         }
         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(this.getObsQueryOptions()));
-        this.obsQueryFields = React__namespace.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);
+}
+function getObsQueryOptions(observable, client, queryHookOptions, watchQueryOptions) {
+    var toMerge = [];
+    var globalDefaults = client.defaultOptions.watchQuery;
+    if (globalDefaults)
+        toMerge.push(globalDefaults);
+    if (queryHookOptions.defaultOptions) {
+        toMerge.push(queryHookOptions.defaultOptions);
+    }
+    toMerge.push(utilities.compact(observable && observable.options, watchQueryOptions));
+    return toMerge.reduce(utilities.mergeOptions);
+}
+function setResult(nextResult, resultData, observable, client, partialRefetch, forceUpdate, callbacks) {
+    var previousResult = resultData.current;
+    if (previousResult && previousResult.data) {
+        resultData.previousData = previousResult.data;
+    }
+    resultData.current = toQueryResult(unsafeHandlePartialRefetch(nextResult, observable, partialRefetch), resultData.previousData, observable, client);
+    forceUpdate();
+    handleErrorOrCompleted(nextResult, previousResult === null || previousResult === void 0 ? void 0 : previousResult[originalResult], callbacks);
+}
+function handleErrorOrCompleted(result, previousResult, callbacks) {
+    if (!result.loading) {
+        var error_1 = toApolloError$1(result);
+        Promise.resolve()
+            .then(function () {
+            if (error_1) {
+                callbacks.onError(error_1);
             }
-        }
-        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, previousResult);
-    };
-    InternalState.prototype.handleErrorOrCompleted = function (result, previousResult) {
-        var _this = this;
-        if (!result.loading) {
-            var error_1 = this.toApolloError(result);
-            Promise.resolve()
-                .then(function () {
-                if (error_1) {
-                    _this.onError(error_1);
-                }
-                else if (result.data &&
-                    (previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus) !== result.networkStatus &&
-                    result.networkStatus === core.NetworkStatus.ready) {
-                    _this.onCompleted(result.data);
-                }
-            })
-                .catch(function (error) {
-                globalThis.__DEV__ !== false && globals.invariant.warn(error);
-            });
-        }
-    };
-    InternalState.prototype.toApolloError = function (result) {
-        return utilities.isNonEmptyArray(result.errors) ?
-            new errors.ApolloError({ graphQLErrors: result.errors })
-            : result.error;
-    };
-    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: !this.queryHookOptions.skip, 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) &&
-            this.observable.options.fetchPolicy !== "cache-only") {
-            Object.assign(result, {
-                loading: true,
-                networkStatus: core.NetworkStatus.refetch,
-            });
-            this.observable.refetch();
-        }
+            else if (result.data &&
+                (previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus) !== result.networkStatus &&
+                result.networkStatus === core.NetworkStatus.ready) {
+                callbacks.onCompleted(result.data);
+            }
+        })
+            .catch(function (error) {
+            globalThis.__DEV__ !== false && globals.invariant.warn(error);
+        });
+    }
+}
+function getCurrentResult(resultData, observable, callbacks, partialRefetch, client) {
+    if (!resultData.current) {
+        setResult(observable.getCurrentResult(), resultData, observable, client, partialRefetch, function () { }, callbacks);
+    }
+    return resultData.current;
+}
+function getDefaultFetchPolicy(queryHookDefaultOptions, clientDefaultOptions) {
+    var _a;
+    return ((queryHookDefaultOptions === null || queryHookDefaultOptions === void 0 ? void 0 : queryHookDefaultOptions.fetchPolicy) ||
+        ((_a = clientDefaultOptions === null || clientDefaultOptions === void 0 ? void 0 : clientDefaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||
+        "cache-first");
+}
+function toApolloError$1(result) {
+    return utilities.isNonEmptyArray(result.errors) ?
+        new errors.ApolloError({ graphQLErrors: result.errors })
+        : result.error;
+}
+function toQueryResult(result, previousData, observable, client) {
+    var data = result.data; result.partial; var resultWithoutPartial = tslib.__rest(result, ["data", "partial"]);
+    var queryResult = tslib.__assign(tslib.__assign({ data: data }, resultWithoutPartial), { client: client, observable: observable, variables: observable.variables, called: result !== ssrDisabledResult && result !== skipStandbyResult, previousData: previousData });
+    Object.defineProperty(queryResult, originalResult, { value: result });
+    if (!queryResult.error && utilities.isNonEmptyArray(result.errors)) {
+        queryResult.error = new errors.ApolloError({ graphQLErrors: result.errors });
+    }
+    return queryResult;
+}
+function unsafeHandlePartialRefetch(result, observable, partialRefetch) {
+    if (result.partial &&
+        partialRefetch &&
+        !result.loading &&
+        (!result.data || Object.keys(result.data).length === 0) &&
+        observable.options.fetchPolicy !== "cache-only") {
+        observable.refetch();
+        return tslib.__assign(tslib.__assign({}, result), { loading: true, networkStatus: core.NetworkStatus.refetch });
+    }
+    return result;
+}
+var ssrDisabledResult = utilities.maybeDeepFreeze({
+    loading: true,
+    data: void 0,
+    error: void 0,
+    networkStatus: core.NetworkStatus.loading,
+});
+var skipStandbyResult = utilities.maybeDeepFreeze({
+    loading: false,
+    data: void 0,
+    error: void 0,
+    networkStatus: core.NetworkStatus.ready,
+});
+function bindObservableMethods(observable) {
+    return {
+        refetch: observable.refetch.bind(observable),
+        reobserve: observable.reobserve.bind(observable),
+        fetchMore: observable.fetchMore.bind(observable),
+        updateQuery: observable.updateQuery.bind(observable),
+        startPolling: observable.startPolling.bind(observable),
+        stopPolling: observable.stopPolling.bind(observable),
+        subscribeToMore: observable.subscribeToMore.bind(observable),
     };
-    return InternalState;
-}());
+}
 
 var EAGER_METHODS = [
     "refetch",
@@ -454,6 +460,7 @@ var EAGER_METHODS = [
     "fetchMore",
     "updateQuery",
     "startPolling",
+    "stopPolling",
     "subscribeToMore",
 ];
 function useLazyQuery(query, options) {
@@ -465,11 +472,11 @@ function useLazyQuery(query, options) {
     var document = (_a = merged === null || merged === void 0 ? void 0 : merged.query) !== null && _a !== void 0 ? _a : query;
     optionsRef.current = options;
     queryRef.current = document;
-    var internalState = useInternalState(useApolloClient(options && options.client), document);
-    var useQueryResult = internalState.useQuery(tslib.__assign(tslib.__assign({}, merged), { skip: !execOptionsRef.current }));
-    var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||
-        internalState.getDefaultFetchPolicy();
-    var forceUpdateState = internalState.forceUpdateState, obsQueryFields = internalState.obsQueryFields;
+    var queryHookOptions = tslib.__assign(tslib.__assign({}, merged), { skip: !execOptionsRef.current });
+    var _b = useQueryInternals(document, queryHookOptions), obsQueryFields = _b.obsQueryFields, useQueryResult = _b.result, client = _b.client, resultData = _b.resultData, observable = _b.observable, onQueryExecuted = _b.onQueryExecuted;
+    var initialFetchPolicy = observable.options.initialFetchPolicy ||
+        getDefaultFetchPolicy(queryHookOptions.defaultOptions, client.defaultOptions);
+    var forceUpdateState = React__namespace.useReducer(function (tick) { return tick + 1; }, 0)[1];
     var eagerMethods = React__namespace.useMemo(function () {
         var eagerMethods = {};
         var _loop_1 = function (key) {
@@ -496,13 +503,50 @@ function useLazyQuery(query, options) {
                 fetchPolicy: initialFetchPolicy,
             };
         var options = utilities.mergeOptions(optionsRef.current, tslib.__assign({ query: queryRef.current }, execOptionsRef.current));
-        var promise = internalState
-            .executeQuery(tslib.__assign(tslib.__assign({}, options), { skip: false }))
-            .then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
+        var promise = executeQuery(resultData, observable, client, document, tslib.__assign(tslib.__assign({}, options), { skip: false }), onQueryExecuted).then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
         promise.catch(function () { });
         return promise;
-    }, [eagerMethods, initialFetchPolicy, internalState]);
-    return [execute, result];
+    }, [
+        client,
+        document,
+        eagerMethods,
+        initialFetchPolicy,
+        observable,
+        resultData,
+        onQueryExecuted,
+    ]);
+    var executeRef = React__namespace.useRef(execute);
+    useIsomorphicLayoutEffect(function () {
+        executeRef.current = execute;
+    });
+    var stableExecute = React__namespace.useCallback(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return executeRef.current.apply(executeRef, args);
+    }, []);
+    return [stableExecute, result];
+}
+function executeQuery(resultData, observable, client, currentQuery, options, onQueryExecuted) {
+    var query = options.query || currentQuery;
+    var watchQueryOptions = createMakeWatchQueryOptions(client, query, options, false)(observable);
+    var concast = observable.reobserveAsConcast(getObsQueryOptions(observable, client, options, watchQueryOptions));
+    onQueryExecuted(watchQueryOptions);
+    return new Promise(function (resolve) {
+        var result;
+        concast.subscribe({
+            next: function (value) {
+                result = value;
+            },
+            error: function () {
+                resolve(toQueryResult(observable.getCurrentResult(), resultData.previousData, observable, client));
+            },
+            complete: function () {
+                resolve(toQueryResult(result, resultData.previousData, observable, client));
+            },
+        });
+    });
 }
 
 function useMutation(mutation, options) {
@@ -617,89 +661,67 @@ function useMutation(mutation, options) {
 }
 
 function useSubscription(subscription, options) {
+    if (options === void 0) { options = Object.create(null); }
     var hasIssuedDeprecationWarningRef = React__namespace.useRef(false);
-    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
+    var client = useApolloClient(options.client);
     parser.verifyDocumentType(subscription, parser.DocumentType.Subscription);
-    var _a = React__namespace.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];
     if (!hasIssuedDeprecationWarningRef.current) {
         hasIssuedDeprecationWarningRef.current = true;
-        if (options === null || options === void 0 ? void 0 : options.onSubscriptionData) {
+        if (options.onSubscriptionData) {
             globalThis.__DEV__ !== false && globals.invariant.warn(options.onData ? 52 : 53);
         }
-        if (options === null || options === void 0 ? void 0 : options.onSubscriptionComplete) {
+        if (options.onSubscriptionComplete) {
             globalThis.__DEV__ !== false && globals.invariant.warn(options.onComplete ? 54 : 55);
         }
     }
-    var _b = React__namespace.useState(function () {
-        if (options === null || options === void 0 ? void 0 : options.skip) {
-            return null;
-        }
-        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 canResetObservableRef = React__namespace.useRef(false);
-    React__namespace.useEffect(function () {
-        return function () {
-            canResetObservableRef.current = true;
-        };
-    }, []);
-    var ref = React__namespace.useRef({ client: client, subscription: subscription, options: options });
-    React__namespace.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) ||
-                canResetObservableRef.current) {
-                setResult({
-                    loading: false,
-                    data: void 0,
-                    error: void 0,
-                    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) ||
-                !equal.equal(options === null || options === void 0 ? void 0 : options.variables, (_d = ref.current.options) === null || _d === void 0 ? void 0 : _d.variables))) ||
-            canResetObservableRef.current) {
-            setResult({
-                loading: true,
-                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,
-            }));
-            canResetObservableRef.current = false;
+    var skip = options.skip, fetchPolicy = options.fetchPolicy, errorPolicy = options.errorPolicy, shouldResubscribe = options.shouldResubscribe, context = options.context, extensions = options.extensions, ignoreResults = options.ignoreResults;
+    var variables = useDeepMemo(function () { return options.variables; }, [options.variables]);
+    var recreate = function () {
+        return createSubscription(client, subscription, variables, fetchPolicy, errorPolicy, context, extensions);
+    };
+    var _a = React__namespace.useState(options.skip ? null : recreate), observable = _a[0], setObservable = _a[1];
+    var recreateRef = React__namespace.useRef(recreate);
+    useIsomorphicLayoutEffect(function () {
+        recreateRef.current = recreate;
+    });
+    if (skip) {
+        if (observable) {
+            setObservable((observable = null));
         }
-        Object.assign(ref.current, { client: client, subscription: subscription, options: options });
-    }, [client, subscription, options, canResetObservableRef.current]);
+    }
+    else if (!observable ||
+        ((client !== observable.__.client ||
+            subscription !== observable.__.query ||
+            fetchPolicy !== observable.__.fetchPolicy ||
+            errorPolicy !== observable.__.errorPolicy ||
+            !equal.equal(variables, observable.__.variables)) &&
+            (typeof shouldResubscribe === "function" ?
+                !!shouldResubscribe(options)
+                : shouldResubscribe) !== false)) {
+        setObservable((observable = recreate()));
+    }
+    var optionsRef = React__namespace.useRef(options);
     React__namespace.useEffect(function () {
+        optionsRef.current = options;
+    });
+    var fallbackLoading = !skip && !ignoreResults;
+    var fallbackResult = React__namespace.useMemo(function () { return ({
+        loading: fallbackLoading,
+        error: void 0,
+        data: void 0,
+        variables: variables,
+    }); }, [fallbackLoading, variables]);
+    var ignoreResultsRef = React__namespace.useRef(ignoreResults);
+    useIsomorphicLayoutEffect(function () {
+        ignoreResultsRef.current = ignoreResults;
+    });
+    var ret = useSyncExternalStore(React__namespace.useCallback(function (update) {
         if (!observable) {
-            return;
+            return function () { };
         }
         var subscriptionStopped = false;
+        var variables = observable.__.variables;
+        var client = observable.__.client;
         var subscription = observable.subscribe({
             next: function (fetchResult) {
                 var _a, _b;
@@ -709,18 +731,23 @@ function useSubscription(subscription, options) {
                 var result = {
                     loading: false,
                     data: fetchResult.data,
-                    error: void 0,
-                    variables: options === null || options === void 0 ? void 0 : options.variables,
+                    error: toApolloError$1(fetchResult),
+                    variables: variables,
                 };
-                setResult(result);
-                if ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onData) {
-                    ref.current.options.onData({
+                observable.__.setResult(result);
+                if (!ignoreResultsRef.current)
+                    update();
+                if (result.error) {
+                    (_b = (_a = optionsRef.current).onError) === null || _b === void 0 ? void 0 : _b.call(_a, result.error);
+                }
+                else if (optionsRef.current.onData) {
+                    optionsRef.current.onData({
                         client: client,
                         data: result,
                     });
                 }
-                else if ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onSubscriptionData) {
-                    ref.current.options.onSubscriptionData({
+                else if (optionsRef.current.onSubscriptionData) {
+                    optionsRef.current.onSubscriptionData({
                         client: client,
                         subscriptionData: result,
                     });
@@ -728,24 +755,27 @@ function useSubscription(subscription, options) {
             },
             error: function (error) {
                 var _a, _b;
+                error =
+                    error instanceof core.ApolloError ? error : (new core.ApolloError({ protocolErrors: [error] }));
                 if (!subscriptionStopped) {
-                    setResult({
+                    observable.__.setResult({
                         loading: false,
                         data: void 0,
                         error: error,
-                        variables: options === null || options === void 0 ? void 0 : options.variables,
+                        variables: variables,
                     });
-                    (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+                    if (!ignoreResultsRef.current)
+                        update();
+                    (_b = (_a = optionsRef.current).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
                 }
             },
             complete: function () {
-                var _a, _b;
                 if (!subscriptionStopped) {
-                    if ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onComplete) {
-                        ref.current.options.onComplete();
+                    if (optionsRef.current.onComplete) {
+                        optionsRef.current.onComplete();
                     }
-                    else if ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onSubscriptionComplete) {
-                        ref.current.options.onSubscriptionComplete();
+                    else if (optionsRef.current.onSubscriptionComplete) {
+                        optionsRef.current.onSubscriptionComplete();
                     }
                 }
             },
@@ -756,8 +786,43 @@ function useSubscription(subscription, options) {
                 subscription.unsubscribe();
             });
         };
-    }, [observable]);
-    return result;
+    }, [observable]), function () {
+        return observable && !skip && !ignoreResults ?
+            observable.__.result
+            : fallbackResult;
+    });
+    return React__namespace.useMemo(function () { return (tslib.__assign(tslib.__assign({}, ret), { restart: function () {
+            globals.invariant(!optionsRef.current.skip, 56);
+            setObservable(recreateRef.current());
+        } })); }, [ret]);
+}
+function createSubscription(client, query, variables, fetchPolicy, errorPolicy, context, extensions) {
+    var options = {
+        query: query,
+        variables: variables,
+        fetchPolicy: fetchPolicy,
+        errorPolicy: errorPolicy,
+        context: context,
+        extensions: extensions,
+    };
+    var __ = tslib.__assign(tslib.__assign({}, options), { client: client, result: {
+            loading: true,
+            data: void 0,
+            error: void 0,
+            variables: variables,
+        }, setResult: function (result) {
+            __.result = result;
+        } });
+    var observable = null;
+    return Object.assign(new core.Observable(function (observer) {
+        if (!observable) {
+            observable = client.subscribe(options);
+        }
+        var sub = observable.subscribe(observer);
+        return function () { return sub.unsubscribe(); };
+    }), {
+        __: __,
+    });
 }
 
 function useReactiveVar(rv) {
@@ -876,7 +941,7 @@ function _useSuspenseQuery(query, options) {
         setPromise([queryRef.key, queryRef.promise]);
         return promise;
     }, [queryRef]);
-    var subscribeToMore = React__namespace.useCallback(function (options) { return queryRef.observable.subscribeToMore(options); }, [queryRef]);
+    var subscribeToMore = queryRef.observable.subscribeToMore;
     return React__namespace.useMemo(function () {
         return {
             client: client,
@@ -903,11 +968,11 @@ function validateFetchPolicy(fetchPolicy) {
         "no-cache",
         "cache-and-network",
     ];
-    globals.invariant(supportedFetchPolicies.includes(fetchPolicy), 56, fetchPolicy);
+    globals.invariant(supportedFetchPolicies.includes(fetchPolicy), 57, fetchPolicy);
 }
 function validatePartialDataReturn(fetchPolicy, returnPartialData) {
     if (fetchPolicy === "no-cache" && returnPartialData) {
-        globalThis.__DEV__ !== false && globals.invariant.warn(57);
+        globalThis.__DEV__ !== false && globals.invariant.warn(58);
     }
 }
 function toApolloError(result) {
@@ -984,7 +1049,11 @@ function _useBackgroundQuery(query, options) {
     React__namespace.useEffect(function () { return queryRef.softRetain(); }, [queryRef]);
     return [
         didFetchResult.current ? wrappedQueryRef : void 0,
-        { fetchMore: fetchMore, refetch: refetch },
+        {
+            fetchMore: fetchMore,
+            refetch: refetch,
+            subscribeToMore: queryRef.observable.subscribeToMore,
+        },
     ];
 }
 
@@ -1041,10 +1110,14 @@ function useLoadableQuery(query, options) {
         calledDuringRender,
         client,
     ]);
+    var subscribeToMore = React__namespace.useCallback(function (options) {
+        globals.invariant(internalQueryRef, 51);
+        return internalQueryRef.observable.subscribeToMore(options);
+    }, [internalQueryRef]);
     var reset = React__namespace.useCallback(function () {
         setQueryRef(null);
     }, []);
-    return [loadQuery, queryRef, { fetchMore: fetchMore, refetch: refetch, reset: reset }];
+    return [loadQuery, queryRef, { fetchMore: fetchMore, refetch: refetch, reset: reset, subscribeToMore: subscribeToMore }];
 }
 
 function useQueryRefHandlers(queryRef) {
@@ -1075,7 +1148,11 @@ function _useQueryRefHandlers(queryRef) {
         setWrappedQueryRef(internal.wrapQueryRef(internalQueryRef));
         return promise;
     }, [internalQueryRef]);
-    return { refetch: refetch, fetchMore: fetchMore };
+    return {
+        refetch: refetch,
+        fetchMore: fetchMore,
+        subscribeToMore: internalQueryRef.observable.subscribeToMore,
+    };
 }
 
 function useReadQuery(queryRef) {