@apollo/client 3.10.7 → 3.11.0-rc.0

package/apollo-client.cjs

@@ -31,7 +31,7 @@ function _interopNamespace(e) {
 var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-var version = "3.10.7";
+var version = "3.11.0-rc.0";
 
 function maybe(thunk) {
     try {
@@ -145,7 +145,7 @@ function shouldInclude(_a, variables) {
         if (ifArgument.value.kind === "Variable") {
             evaledValue =
                 variables && variables[ifArgument.value.name.value];
-            invariant(evaledValue !== void 0, 68, directive.name.value);
+            invariant(evaledValue !== void 0, 69, directive.name.value);
         }
         else {
             evaledValue = ifArgument.value.value;
@@ -180,12 +180,12 @@ function getInclusionDirectives(directives) {
                 return;
             var directiveArguments = directive.arguments;
             var directiveName = directive.name.value;
-            invariant(directiveArguments && directiveArguments.length === 1, 69, directiveName);
+            invariant(directiveArguments && directiveArguments.length === 1, 70, directiveName);
             var ifArgument = directiveArguments[0];
-            invariant(ifArgument.name && ifArgument.name.value === "if", 70, directiveName);
+            invariant(ifArgument.name && ifArgument.name.value === "if", 71, directiveName);
             var ifValue = ifArgument.value;
             invariant(ifValue &&
-                (ifValue.kind === "Variable" || ifValue.kind === "BooleanValue"), 71, directiveName);
+                (ifValue.kind === "Variable" || ifValue.kind === "BooleanValue"), 72, directiveName);
             result.push({ directive: directive, ifArgument: ifArgument });
         });
     }
@@ -213,7 +213,7 @@ function getFragmentQueryDocument(document, fragmentName) {
     document.definitions.forEach(function (definition) {
         if (definition.kind === "OperationDefinition") {
             throw newInvariantError(
-                72,
+                73,
                 definition.operation,
                 definition.name ? " named '".concat(definition.name.value, "'") : ""
             );
@@ -223,7 +223,7 @@ function getFragmentQueryDocument(document, fragmentName) {
         }
     });
     if (typeof actualFragmentName === "undefined") {
-        invariant(fragments.length === 1, 73, fragments.length);
+        invariant(fragments.length === 1, 74, fragments.length);
         actualFragmentName = fragments[0].name.value;
     }
     var query = tslib.__assign(tslib.__assign({}, document), { definitions: tslib.__spreadArray([
@@ -264,7 +264,7 @@ function getFragmentFromSelection(selection, fragmentMap) {
                 return fragmentMap(fragmentName);
             }
             var fragment = fragmentMap && fragmentMap[fragmentName];
-            invariant(fragment, 74, fragmentName);
+            invariant(fragment, 75, fragmentName);
             return fragment || null;
         }
         default:
@@ -515,7 +515,7 @@ function valueToObjectRepresentation(argObj, name, value, variables) {
         argObj[name.value] = null;
     }
     else {
-        throw newInvariantError(83, name.value, value.kind);
+        throw newInvariantError(84, name.value, value.kind);
     }
 }
 function storeKeyNameFromField(field, variables) {
@@ -649,16 +649,16 @@ function isInlineFragment(selection) {
 }
 
 function checkDocument(doc) {
-    invariant(doc && doc.kind === "Document", 75);
+    invariant(doc && doc.kind === "Document", 76);
     var operations = doc.definitions
         .filter(function (d) { return d.kind !== "FragmentDefinition"; })
         .map(function (definition) {
         if (definition.kind !== "OperationDefinition") {
-            throw newInvariantError(76, definition.kind);
+            throw newInvariantError(77, definition.kind);
         }
         return definition;
     });
-    invariant(operations.length <= 1, 77, operations.length);
+    invariant(operations.length <= 1, 78, operations.length);
     return doc;
 }
 function getOperationDefinition(doc) {
@@ -681,14 +681,14 @@ function getFragmentDefinitions(doc) {
 }
 function getQueryDefinition(doc) {
     var queryDef = getOperationDefinition(doc);
-    invariant(queryDef && queryDef.operation === "query", 78);
+    invariant(queryDef && queryDef.operation === "query", 79);
     return queryDef;
 }
 function getFragmentDefinition(doc) {
-    invariant(doc.kind === "Document", 79);
-    invariant(doc.definitions.length <= 1, 80);
+    invariant(doc.kind === "Document", 80);
+    invariant(doc.definitions.length <= 1, 81);
     var fragmentDef = doc.definitions[0];
-    invariant(fragmentDef.kind === "FragmentDefinition", 81);
+    invariant(fragmentDef.kind === "FragmentDefinition", 82);
     return fragmentDef;
 }
 function getMainDefinition(queryDoc) {
@@ -711,7 +711,7 @@ function getMainDefinition(queryDoc) {
     if (fragmentDefinition) {
         return fragmentDefinition;
     }
-    throw newInvariantError(82);
+    throw newInvariantError(83);
 }
 function getDefaultValues(definition) {
     var defaultValues = Object.create(null);
@@ -762,7 +762,7 @@ var DocumentTransform =  (function () {
                 makeCacheKey: function (document) {
                     var cacheKeys = _this.getCacheKey(document);
                     if (cacheKeys) {
-                        invariant(Array.isArray(cacheKeys), 67);
+                        invariant(Array.isArray(cacheKeys), 68);
                         return stableCacheKeys_1.lookupArray(cacheKeys);
                     }
                 },
@@ -892,7 +892,7 @@ function removeDirectivesFromDocument(directives, doc) {
                 return getInUseByFragmentName(ancestor.name.value);
             }
         }
-        globalThis.__DEV__ !== false && invariant.error(84);
+        globalThis.__DEV__ !== false && invariant.error(85);
         return null;
     };
     var operationCount = 0;
@@ -1944,6 +1944,10 @@ var ApolloError =  (function (_super) {
         _this.networkError = networkError || null;
         _this.message = errorMessage || generateErrorMessage(_this);
         _this.extraInfo = extraInfo;
+        _this.cause =
+            tslib.__spreadArray(tslib.__spreadArray(tslib.__spreadArray([
+                networkError
+            ], (graphQLErrors || []), true), (protocolErrors || []), true), (clientErrors || []), true).find(function (e) { return !!e; }) || null;
         _this.__proto__ = ApolloError.prototype;
         return _this;
     }
@@ -4920,6 +4924,7 @@ var ObservableQuery =  (function (_super) {
         _this.queryManager = queryManager;
         _this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);
         _this.isTornDown = false;
+        _this.subscribeToMore = _this.subscribeToMore.bind(_this);
         var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? "cache-first" : _d;
         var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e,
         _f = options.initialFetchPolicy,
@@ -5323,7 +5328,8 @@ var ObservableQuery =  (function (_super) {
                 newOptions.variables &&
                 !equal.equal(newOptions.variables, oldVariables) &&
                 options.fetchPolicy !== "standby" &&
-                options.fetchPolicy === oldFetchPolicy) {
+                (options.fetchPolicy === oldFetchPolicy ||
+                    typeof options.nextFetchPolicy === "function")) {
                 this.applyNextFetchPolicy("variables-changed", options);
                 if (newNetworkStatus === void 0) {
                     newNetworkStatus = exports.NetworkStatus.setVariables;
@@ -6131,7 +6137,7 @@ var QueryManager =  (function () {
                         this.broadcastQueries();
                         self = this;
                         return [2 , new Promise(function (resolve, reject) {
-                                return asyncMap(self.getObservableFromLink(mutation, tslib.__assign(tslib.__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, false), function (result) {
+                                return asyncMap(self.getObservableFromLink(mutation, tslib.__assign(tslib.__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, {}, false), function (result) {
                                     if (graphQLResultHasError(result) && errorPolicy === "none") {
                                         throw new ApolloError({
                                             graphQLErrors: getGraphQLErrorsFromResult(result),
@@ -6551,11 +6557,11 @@ var QueryManager =  (function () {
     };
     QueryManager.prototype.startGraphQLSubscription = function (_a) {
         var _this = this;
-        var query = _a.query, fetchPolicy = _a.fetchPolicy, _b = _a.errorPolicy, errorPolicy = _b === void 0 ? "none" : _b, variables = _a.variables, _c = _a.context, context = _c === void 0 ? {} : _c;
+        var query = _a.query, fetchPolicy = _a.fetchPolicy, _b = _a.errorPolicy, errorPolicy = _b === void 0 ? "none" : _b, variables = _a.variables, _c = _a.context, context = _c === void 0 ? {} : _c, _d = _a.extensions, extensions = _d === void 0 ? {} : _d;
         query = this.transform(query);
         variables = this.getVariables(query, variables);
         var makeObservable = function (variables) {
-            return _this.getObservableFromLink(query, context, variables).map(function (result) {
+            return _this.getObservableFromLink(query, context, variables, extensions).map(function (result) {
                 if (fetchPolicy !== "no-cache") {
                     if (shouldWriteResult(result, errorPolicy)) {
                         _this.cache.write({
@@ -6622,7 +6628,7 @@ var QueryManager =  (function () {
     QueryManager.prototype.getLocalState = function () {
         return this.localState;
     };
-    QueryManager.prototype.getObservableFromLink = function (query, context, variables,
+    QueryManager.prototype.getObservableFromLink = function (query, context, variables, extensions,
     deduplication) {
         var _this = this;
         var _a;
@@ -6636,6 +6642,7 @@ var QueryManager =  (function () {
                 variables: variables,
                 operationName: getOperationName(serverQuery) || void 0,
                 context: this.prepareContext(tslib.__assign(tslib.__assign({}, context), { forceFetch: !deduplication })),
+                extensions: extensions,
             };
             context = operation.context;
             if (deduplication) {
@@ -6961,10 +6968,7 @@ var ApolloClient =  (function () {
             throw newInvariantError(15);
         }
         var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, documentTransform = options.documentTransform, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b,
-        _c = options.connectToDevTools,
-        connectToDevTools = _c === void 0 ? typeof window === "object" &&
-            !window.__APOLLO_CLIENT__ &&
-            globalThis.__DEV__ !== false : _c, _d = options.queryDeduplication, queryDeduplication = _d === void 0 ? true : _d, defaultOptions = options.defaultOptions, defaultContext = options.defaultContext, _e = options.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? cache.assumeImmutableResults : _e, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;
+        connectToDevTools = options.connectToDevTools, _c = options.queryDeduplication, queryDeduplication = _c === void 0 ? true : _c, defaultOptions = options.defaultOptions, defaultContext = options.defaultContext, _d = options.assumeImmutableResults, assumeImmutableResults = _d === void 0 ? cache.assumeImmutableResults : _d, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version, devtools = options.devtools;
         var link = options.link;
         if (!link) {
             link =
@@ -6976,6 +6980,13 @@ var ApolloClient =  (function () {
         this.queryDeduplication = queryDeduplication;
         this.defaultOptions = defaultOptions || Object.create(null);
         this.typeDefs = typeDefs;
+        this.devtoolsConfig = tslib.__assign(tslib.__assign({}, devtools), { enabled: (devtools === null || devtools === void 0 ? void 0 : devtools.enabled) || connectToDevTools });
+        if (this.devtoolsConfig.enabled === undefined) {
+            this.devtoolsConfig.enabled =
+                typeof window === "object" &&
+                    window.__APOLLO_CLIENT__ &&
+                    globalThis.__DEV__ !== false;
+        }
         if (ssrForceFetchDelay) {
             setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);
         }
@@ -7021,7 +7032,7 @@ var ApolloClient =  (function () {
                 }
                 : void 0,
         });
-        if (connectToDevTools)
+        if (this.devtoolsConfig.enabled)
             this.connectToDevTools();
     }
     ApolloClient.prototype.connectToDevTools = function () {
@@ -7279,7 +7290,7 @@ var useSyncExternalStore = realHook$1 ||
             !didWarnUncachedGetSnapshot &&
             value !== getSnapshot()) {
             didWarnUncachedGetSnapshot = true;
-            globalThis.__DEV__ !== false && invariant.error(58);
+            globalThis.__DEV__ !== false && invariant.error(59);
         }
         var _a = React__namespace.useState({
             inst: { value: value, getSnapshot: getSnapshot },
@@ -7347,7 +7358,7 @@ function parser(document) {
     if (cached)
         return cached;
     var variables, type, name;
-    invariant(!!document && !!document.kind, 60, document);
+    invariant(!!document && !!document.kind, 61, document);
     var fragments = [];
     var queries = [];
     var mutations = [];
@@ -7375,10 +7386,10 @@ function parser(document) {
     invariant(!fragments.length ||
         queries.length ||
         mutations.length ||
-        subscriptions.length, 61);
+        subscriptions.length, 62);
     invariant(
         queries.length + mutations.length + subscriptions.length <= 1,
-        62,
+        63,
         document,
         queries.length,
         subscriptions.length,
@@ -7390,7 +7401,7 @@ function parser(document) {
     var definitions = queries.length ? queries
         : mutations.length ? mutations
             : subscriptions;
-    invariant(definitions.length === 1, 63, document, definitions.length);
+    invariant(definitions.length === 1, 64, document, definitions.length);
     var definition = definitions[0];
     variables = definition.variableDefinitions || [];
     if (definition.name && definition.name.kind === "Name") {
@@ -7415,7 +7426,7 @@ function verifyDocumentType(document, type) {
     var usedOperationName = operationName(operation.type);
     invariant(
         operation.type === type,
-        64,
+        65,
         requiredOperationName,
         requiredOperationName,
         usedOperationName
@@ -7433,7 +7444,7 @@ function useDeepMemo(memoFn, deps) {
 var useIsomorphicLayoutEffect = canUseDOM ? React__namespace.useLayoutEffect : React__namespace.useEffect;
 
 var Ctx;
-function noop() { }
+function noop$1() { }
 function useRenderGuard() {
     if (!Ctx) {
         Ctx = React__namespace.createContext(null);
@@ -7442,7 +7453,7 @@ function useRenderGuard() {
  function () {
         var orig = console.error;
         try {
-            console.error = noop;
+            console.error = noop$1;
             React__namespace["useContext" ](Ctx);
             return true;
         }
@@ -7488,181 +7499,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 = React__namespace.useState(createInternalState), state = _a[0], updateState = _a[1];
-    if (client !== state.client || query !== state.query) {
-        updateState((state = createInternalState(state)));
-    }
-    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 = maybeDeepFreeze({
-            loading: true,
-            data: void 0,
-            error: void 0,
-            networkStatus: exports.NetworkStatus.loading,
-        });
-        this.skipStandbyResult = maybeDeepFreeze({
-            loading: false,
-            data: void 0,
-            error: void 0,
-            networkStatus: exports.NetworkStatus.ready,
-        });
-        this.toQueryResultCache = new (canUseWeakMap ? WeakMap : Map)();
+        var _a;
         verifyDocumentType(query, exports.DocumentType.Query);
-        var previousResult = previous && previous.result;
-        var previousData = previousResult && previousResult.data;
-        if (previousData) {
-            this.previousData = previousData;
-        }
+        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;
     }
-    InternalState.prototype.forceUpdateState = function () {
-        globalThis.__DEV__ !== false && invariant.warn(51);
-    };
-    InternalState.prototype.executeQuery = function (options) {
-        var _this = this;
-        var _a;
-        if (options.query) {
-            Object.assign(this, { query: options.query });
-        }
-        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(getApolloContext()).renderPromises;
-        this.useOptions(options);
-        var obsQuery = this.useObservableQuery();
-        var result = useSyncExternalStore(
-        React__namespace.useCallback(function (handleStoreChange) {
-            if (_this.renderPromises) {
-                return function () { };
-            }
-            _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: exports.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 = React__namespace.useState(createInternalState), internalState = _a[0], updateInternalState = _a[1];
+    function onQueryExecuted(watchQueryOptions) {
         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;
-            }
-        }
-        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(compact(this.observable && this.observable.options, this.watchQueryOptions));
-        return toMerge.reduce(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 &&
+        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,
+            }) }));
+    }
+    if (client !== internalState.client || query !== internalState.query) {
+        var newInternalState = createInternalState(internalState);
+        updateInternalState(newInternalState);
+        return [newInternalState, onQueryExecuted];
+    }
+    return [internalState, onQueryExecuted];
+}
+function useQueryInternals(query, options) {
+    var client = useApolloClient(options.client);
+    var renderPromises = React__namespace.useContext(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,
+    };
+}
+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 () { };
+        }
+        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;
+            }
+            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: exports.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);
+        }
+    }
+}
+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";
@@ -7671,117 +7686,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);
-            }
-        }
-        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 === exports.NetworkStatus.ready) {
-                    _this.onCompleted(result.data);
-                }
-            })
-                .catch(function (error) {
-                globalThis.__DEV__ !== false && invariant.warn(error);
-            });
-        }
-    };
-    InternalState.prototype.toApolloError = function (result) {
-        return isNonEmptyArray(result.errors) ?
-            new 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 && isNonEmptyArray(result.errors)) {
-            queryResult.error = new 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: exports.NetworkStatus.refetch,
-            });
-            this.observable.refetch();
-        }
+}
+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(compact(observable && observable.options, watchQueryOptions));
+    return toMerge.reduce(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);
+            }
+            else if (result.data &&
+                (previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus) !== result.networkStatus &&
+                result.networkStatus === exports.NetworkStatus.ready) {
+                callbacks.onCompleted(result.data);
+            }
+        })
+            .catch(function (error) {
+            globalThis.__DEV__ !== false && 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 isNonEmptyArray(result.errors) ?
+        new 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 && isNonEmptyArray(result.errors)) {
+        queryResult.error = new 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: exports.NetworkStatus.refetch });
+    }
+    return result;
+}
+var ssrDisabledResult = maybeDeepFreeze({
+    loading: true,
+    data: void 0,
+    error: void 0,
+    networkStatus: exports.NetworkStatus.loading,
+});
+var skipStandbyResult = maybeDeepFreeze({
+    loading: false,
+    data: void 0,
+    error: void 0,
+    networkStatus: exports.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",
@@ -7789,6 +7806,7 @@ var EAGER_METHODS = [
     "fetchMore",
     "updateQuery",
     "startPolling",
+    "stopPolling",
     "subscribeToMore",
 ];
 function useLazyQuery(query, options) {
@@ -7800,11 +7818,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) {
@@ -7831,13 +7849,50 @@ function useLazyQuery(query, options) {
                 fetchPolicy: initialFetchPolicy,
             };
         var options = 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) {
@@ -7952,89 +8007,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);
     verifyDocumentType(subscription, exports.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 && invariant.warn(options.onData ? 52 : 53);
         }
-        if (options === null || options === void 0 ? void 0 : options.onSubscriptionComplete) {
+        if (options.onSubscriptionComplete) {
             globalThis.__DEV__ !== false && 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;
-        }
-        Object.assign(ref.current, { client: client, subscription: subscription, options: options });
-    }, [client, subscription, options, canResetObservableRef.current]);
+    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));
+        }
+    }
+    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;
@@ -8044,18 +8077,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,
                     });
@@ -8063,24 +8101,27 @@ function useSubscription(subscription, options) {
             },
             error: function (error) {
                 var _a, _b;
+                error =
+                    error instanceof ApolloError ? error : (new 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();
                     }
                 }
             },
@@ -8091,8 +8132,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 () {
+            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 zenObservableTs.Observable(function (observer) {
+        if (!observable) {
+            observable = client.subscribe(options);
+        }
+        var sub = observable.subscribe(observer);
+        return function () { return sub.unsubscribe(); };
+    }), {
+        __: __,
+    });
 }
 
 function useReactiveVar(rv) {
@@ -8164,7 +8240,7 @@ function wrapQueryRef(internalQueryRef) {
     return ref;
 }
 function assertWrappedQueryRef(queryRef) {
-    invariant(!queryRef || QUERY_REFERENCE_SYMBOL in queryRef, 59);
+    invariant(!queryRef || QUERY_REFERENCE_SYMBOL in queryRef, 60);
 }
 function getWrappedPromise(queryRef) {
     var internalQueryRef = unwrapQueryRef(queryRef);
@@ -8508,7 +8584,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,
@@ -8535,11 +8611,11 @@ function validateFetchPolicy(fetchPolicy) {
         "no-cache",
         "cache-and-network",
     ];
-    invariant(supportedFetchPolicies.includes(fetchPolicy), 56, fetchPolicy);
+    invariant(supportedFetchPolicies.includes(fetchPolicy), 57, fetchPolicy);
 }
 function validatePartialDataReturn(fetchPolicy, returnPartialData) {
     if (fetchPolicy === "no-cache" && returnPartialData) {
-        globalThis.__DEV__ !== false && invariant.warn(57);
+        globalThis.__DEV__ !== false && invariant.warn(58);
     }
 }
 function toApolloError(result) {
@@ -8616,7 +8692,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,
+        },
     ];
 }
 
@@ -8673,10 +8753,14 @@ function useLoadableQuery(query, options) {
         calledDuringRender,
         client,
     ]);
+    var subscribeToMore = React__namespace.useCallback(function (options) {
+        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) {
@@ -8707,7 +8791,11 @@ function _useQueryRefHandlers(queryRef) {
         setWrappedQueryRef(wrapQueryRef(internalQueryRef));
         return promise;
     }, [internalQueryRef]);
-    return { refetch: refetch, fetchMore: fetchMore };
+    return {
+        refetch: refetch,
+        fetchMore: fetchMore,
+        subscribeToMore: internalQueryRef.observable.subscribeToMore,
+    };
 }
 
 function useReadQuery(queryRef) {
@@ -8742,6 +8830,9 @@ function _useReadQuery(queryRef) {
 }
 
 function createQueryPreloader(client) {
+    return wrapHook("createQueryPreloader", _createQueryPreloader, client)(client);
+}
+var _createQueryPreloader = function (client) {
     return function preloadQuery(query, options) {
         var _a, _b;
         if (options === void 0) { options = Object.create(null); }
@@ -8750,7 +8841,7 @@ function createQueryPreloader(client) {
         });
         return wrapQueryRef(queryRef);
     };
-}
+};
 
 exports.setLogVerbosity = tsInvariant.setVerbosity;
 exports.Observable = zenObservableTs.Observable;