@apollo/client 3.13.9-rc.0 → 3.14.0-alpha.0

package/react/hooks/hooks.cjs.native.js

@@ -0,0 +1,1495 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var globals = require('../../utilities/globals');
+var React = require('rehackt');
+var context = require('../context');
+var tslib = require('tslib');
+var utilities = require('../../utilities');
+var equal = require('@wry/equality');
+var errors = require('../../errors');
+var core = require('../../core');
+var parser = require('../parser');
+var optimism = require('optimism');
+var tsInvariant = require('ts-invariant');
+var internal = require('../internal');
+var cache = require('../../cache');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        for (var k in e) {
+            n[k] = e[k];
+        }
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
+
+function useApolloClient(override) {
+    var context$1 = React__namespace.useContext(context.getApolloContext());
+    var client = override || context$1.client;
+    globals.invariant(!!client, 68);
+    return client;
+}
+
+var didWarnUncachedGetSnapshot = false;
+var uSESKey = "useSyncExternalStore";
+var realHook$1 = React__namespace[uSESKey];
+var useSyncExternalStore = realHook$1 ||
+    (function (subscribe, getSnapshot, getServerSnapshot) {
+        var value = getSnapshot();
+        if (
+        globalThis.__DEV__ !== false &&
+            !didWarnUncachedGetSnapshot &&
+            value !== getSnapshot()) {
+            didWarnUncachedGetSnapshot = true;
+            globalThis.__DEV__ !== false && globals.invariant.error(81);
+        }
+        var _a = React__namespace.useState({
+            inst: { value: value, getSnapshot: getSnapshot },
+        }), inst = _a[0].inst, forceUpdate = _a[1];
+        if (utilities.canUseLayoutEffect) {
+            React__namespace.useLayoutEffect(function () {
+                Object.assign(inst, { value: value, getSnapshot: getSnapshot });
+                if (checkIfSnapshotChanged(inst)) {
+                    forceUpdate({ inst: inst });
+                }
+            }, [subscribe, value, getSnapshot]);
+        }
+        else {
+            Object.assign(inst, { value: value, getSnapshot: getSnapshot });
+        }
+        React__namespace.useEffect(function () {
+            if (checkIfSnapshotChanged(inst)) {
+                forceUpdate({ inst: inst });
+            }
+            return subscribe(function handleStoreChange() {
+                if (checkIfSnapshotChanged(inst)) {
+                    forceUpdate({ inst: inst });
+                }
+            });
+        }, [subscribe]);
+        return value;
+    });
+function checkIfSnapshotChanged(_a) {
+    var value = _a.value, getSnapshot = _a.getSnapshot;
+    try {
+        return value !== getSnapshot();
+    }
+    catch (_b) {
+        return true;
+    }
+}
+
+function useDeepMemo(memoFn, deps) {
+    var ref = React__namespace.useRef(void 0);
+    if (!ref.current || !equal.equal(ref.current.deps, deps)) {
+        ref.current = { value: memoFn(), deps: deps };
+    }
+    return ref.current.value;
+}
+
+var useIsomorphicLayoutEffect = utilities.canUseDOM ? React__namespace.useLayoutEffect : React__namespace.useEffect;
+
+var Ctx;
+function noop$1() { }
+function useRenderGuard() {
+    if (!Ctx) {
+        Ctx = React__namespace.createContext(null);
+    }
+    return React__namespace.useCallback(
+ function () {
+        var orig = console.error;
+        try {
+            console.error = noop$1;
+            React__namespace["useContext" ](Ctx);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+        finally {
+            console.error = orig;
+        }
+    }, []);
+}
+
+var slot = new optimism.Slot();
+function isMuted(name) {
+    return (slot.getValue() || []).includes(name);
+}
+function muteDeprecations(name) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return slot.withValue.apply(slot, tslib.__spreadArray([Array.isArray(name) ? name : [name]], args, false));
+}
+function warnRemovedOption(options, name, callSite, recommendation) {
+    if (recommendation === void 0) { recommendation = "Please remove this option."; }
+    warnDeprecated(name, function () {
+        if (name in options) {
+            globalThis.__DEV__ !== false && globals.invariant.warn(91, callSite, name, recommendation);
+        }
+    });
+}
+function warnDeprecated(name, cb) {
+    if (!isMuted(name)) {
+        cb();
+    }
+}
+
+function useWarnRemovedOption(options, name, callSite, recommendation) {
+    "use no memo";
+    if (recommendation === void 0) { recommendation = "Please remove this option."; }
+    var didWarn = React__namespace.useRef(false);
+    if (name in options && !didWarn.current) {
+        globalThis.__DEV__ !== false && globals.invariant.warn(67, callSite, name, recommendation);
+        didWarn.current = true;
+    }
+}
+
+var useKey = "use";
+var realHook = React__namespace[useKey];
+var __use = realHook ||
+    function __use(promise) {
+        var statefulPromise = utilities.wrapPromiseWithState(promise);
+        switch (statefulPromise.status) {
+            case "pending":
+                throw statefulPromise;
+            case "rejected":
+                throw statefulPromise.reason;
+            case "fulfilled":
+                return statefulPromise.value;
+        }
+    };
+
+var wrapperSymbol = Symbol.for("apollo.hook.wrappers");
+function wrapHook(hookName, useHook, clientOrObsQuery) {
+    var queryManager = clientOrObsQuery["queryManager"];
+    var wrappers = queryManager && queryManager[wrapperSymbol];
+    var wrapper = wrappers && wrappers[hookName];
+    return wrapper ? wrapper(useHook) : useHook;
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+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) {
+    if (globalThis.__DEV__ !== false) {
+        useWarnRemovedOption(options, "canonizeResults", "useQuery");
+        useWarnRemovedOption(options, "partialRefetch", "useQuery");
+        useWarnRemovedOption(options, "defaultOptions", "useQuery", "Pass the options directly to the hook instead.");
+        useWarnRemovedOption(options, "onCompleted", "useQuery", "If your `onCompleted` callback sets local state, switch to use derived state using `data` returned from the hook instead. Use `useEffect` to perform side-effects as a result of updates to `data`.");
+        useWarnRemovedOption(options, "onError", "useQuery", "If your `onError` callback sets local state, switch to use derived state using `data`, `error` or `errors` returned from the hook instead. Use `useEffect` if you need to perform side-effects as a result of updates to `data`, `error` or `errors`.");
+    }
+    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, options, renderPromises, makeWatchQueryOptions) {
+    function createInternalState(previous) {
+        var _a;
+        parser.verifyDocumentType(query, parser.DocumentType.Query);
+        var internalState = {
+            client: client,
+            query: query,
+            observable:
+            (renderPromises &&
+                renderPromises.getSSRObservable(makeWatchQueryOptions())) ||
+                core.ObservableQuery["inactiveOnCreation"].withValue(!renderPromises, function () {
+                    return muteDeprecations("canonizeResults", function () {
+                        return 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), 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,
+            }) }));
+    }
+    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(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]);
+    useRegisterSSRObservable(observable, renderPromises, ssrAllowed);
+    var result = useObservableSubscriptionResult(resultData, observable, client, options, watchQueryOptions, 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, options, watchQueryOptions, disableNetworkFetches, partialRefetch, isSyncSSR, callbacks) {
+    var callbackRef = React__namespace.useRef(callbacks);
+    React__namespace.useEffect(function () {
+        callbackRef.current = callbacks;
+    });
+    var resultOverride = ((isSyncSSR || disableNetworkFetches) &&
+        options.ssr === false &&
+        !options.skip) ?
+        ssrDisabledResult
+        : options.skip || watchQueryOptions.fetchPolicy === "standby" ?
+            skipStandbyResult
+            : void 0;
+    var previousData = resultData.previousData;
+    var currentResultOverride = React__namespace.useMemo(function () {
+        return resultOverride &&
+            toQueryResult(resultOverride, previousData, observable, client);
+    }, [client, observable, resultOverride, previousData]);
+    return useSyncExternalStore(React__namespace.useCallback(function (handleStoreChange) {
+        if (isSyncSSR) {
+            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: 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,
+        isSyncSSR,
+        observable,
+        resultData,
+        partialRefetch,
+        client,
+    ]), function () {
+        return currentResultOverride ||
+            getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);
+    }, function () {
+        return currentResultOverride ||
+            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 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";
+        }
+        if (!watchQueryOptions.variables) {
+            watchQueryOptions.variables = {};
+        }
+        if (skip) {
+            watchQueryOptions.initialFetchPolicy =
+                watchQueryOptions.initialFetchPolicy ||
+                    watchQueryOptions.fetchPolicy ||
+                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);
+            watchQueryOptions.fetchPolicy = "standby";
+        }
+        else if (!watchQueryOptions.fetchPolicy) {
+            watchQueryOptions.fetchPolicy =
+                (observable === null || observable === void 0 ? void 0 : observable.options.initialFetchPolicy) ||
+                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);
+        }
+        return watchQueryOptions;
+    };
+}
+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;
+    }
+    if (!nextResult.error && utilities.isNonEmptyArray(nextResult.errors)) {
+        nextResult.error = new errors.ApolloError({ graphQLErrors: nextResult.errors });
+    }
+    resultData.current = toQueryResult(unsafeHandlePartialRefetch(nextResult, observable, partialRefetch), resultData.previousData, observable, client);
+    forceUpdate();
+    handleErrorOrCompleted(nextResult, previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus, callbacks);
+}
+function handleErrorOrCompleted(result, previousNetworkStatus, 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 &&
+                previousNetworkStatus !== 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 });
+    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: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (globalThis.__DEV__ !== false) {
+                globalThis.__DEV__ !== false && globals.invariant.warn(73);
+            }
+            return observable.reobserve.apply(observable, args);
+        },
+        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),
+    };
+}
+
+var version = "3.14.0-alpha.0";
+
+function maybe(thunk) {
+    try {
+        return thunk();
+    }
+    catch (_a) { }
+}
+
+var global$1 = (maybe(function () { return globalThis; }) ||
+    maybe(function () { return window; }) ||
+    maybe(function () { return self; }) ||
+    maybe(function () { return global; }) ||
+maybe(function () {
+    return maybe.constructor("return this")();
+}));
+
+var prefixCounts = new Map();
+function makeUniqueId(prefix) {
+    var count = prefixCounts.get(prefix) || 1;
+    prefixCounts.set(prefix, count + 1);
+    return "".concat(prefix, ":").concat(count, ":").concat(Math.random().toString(36).slice(2));
+}
+
+function stringifyForDisplay(value, space) {
+    if (space === void 0) { space = 0; }
+    var undefId = makeUniqueId("stringifyForDisplay");
+    return JSON.stringify(value, function (key, value) {
+        return value === void 0 ? undefId : value;
+    }, space)
+        .split(JSON.stringify(undefId))
+        .join("<undefined>");
+}
+
+function wrap(fn) {
+    return function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (typeof message === "number") {
+            var arg0 = message;
+            message = getHandledErrorMsg(arg0);
+            if (!message) {
+                message = getFallbackErrorMsg(arg0, args);
+                args = [];
+            }
+        }
+        fn.apply(void 0, [message].concat(args));
+    };
+}
+var invariant = Object.assign(function invariant(condition, message) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    if (!condition) {
+        tsInvariant.invariant(condition, getHandledErrorMsg(message, args) || getFallbackErrorMsg(message, args));
+    }
+}, {
+    debug: wrap(tsInvariant.invariant.debug),
+    log: wrap(tsInvariant.invariant.log),
+    warn: wrap(tsInvariant.invariant.warn),
+    error: wrap(tsInvariant.invariant.error),
+});
+var ApolloErrorMessageHandler = Symbol.for("ApolloErrorMessageHandler_" + version);
+function stringify(arg) {
+    if (typeof arg == "string") {
+        return arg;
+    }
+    try {
+        return stringifyForDisplay(arg, 2).slice(0, 1000);
+    }
+    catch (_a) {
+        return "<non-serializable>";
+    }
+}
+function getHandledErrorMsg(message, messageArgs) {
+    if (messageArgs === void 0) { messageArgs = []; }
+    if (!message)
+        return;
+    return (global$1[ApolloErrorMessageHandler] &&
+        global$1[ApolloErrorMessageHandler](message, messageArgs.map(stringify)));
+}
+function getFallbackErrorMsg(message, messageArgs) {
+    if (messageArgs === void 0) { messageArgs = []; }
+    if (!message)
+        return;
+    return "An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#".concat(encodeURIComponent(JSON.stringify({
+        version: version,
+        message: message,
+        args: messageArgs.map(stringify),
+    })));
+}
+
+var EAGER_METHODS = [
+    "refetch",
+    "reobserve",
+    "fetchMore",
+    "updateQuery",
+    "startPolling",
+    "stopPolling",
+    "subscribeToMore",
+];
+var REMOVED_EXECUTE_OPTIONS = [
+    "initialFetchPolicy",
+    "onCompleted",
+    "onError",
+    "defaultOptions",
+    "partialRefetch",
+    "canonizeResults",
+];
+var DEPRECATED_EXECUTE_OPTIONS = [
+    "query",
+    "ssr",
+    "client",
+    "fetchPolicy",
+    "nextFetchPolicy",
+    "refetchWritePolicy",
+    "errorPolicy",
+    "pollInterval",
+    "notifyOnNetworkStatusChange",
+    "returnPartialData",
+    "skipPollAttempt",
+];
+function useLazyQuery(query, options) {
+    var _a;
+    if (globalThis.__DEV__ !== false) {
+        var warnOpts = options || {};
+        useWarnRemovedOption(warnOpts, "canonizeResults", "useLazyQuery");
+        useWarnRemovedOption(warnOpts, "variables", "useLazyQuery", "Pass all `variables` to the returned `execute` function instead.");
+        useWarnRemovedOption(warnOpts, "context", "useLazyQuery", "Pass `context` to the returned `execute` function instead.");
+        useWarnRemovedOption(warnOpts, "onCompleted", "useLazyQuery", "If your `onCompleted` callback sets local state, switch to use derived state using `data` returned from the hook instead. Use `useEffect` to perform side-effects as a result of updates to `data`.");
+        useWarnRemovedOption(warnOpts, "onError", "useLazyQuery", "If your `onError` callback sets local state, switch to use derived state using `data`, `error` or `errors` returned from the hook instead. Use `useEffect` if you need to perform side-effects as a result of updates to `data`, `error` or `errors`.");
+        useWarnRemovedOption(warnOpts, "defaultOptions", "useLazyQuery", "Pass the options directly to the hook instead.");
+        useWarnRemovedOption(warnOpts, "initialFetchPolicy", "useLazyQuery", "Use the `fetchPolicy` option instead.");
+        useWarnRemovedOption(warnOpts, "partialRefetch", "useLazyQuery");
+    }
+    var execOptionsRef = React__namespace.useRef(void 0);
+    var optionsRef = React__namespace.useRef(void 0);
+    var queryRef = React__namespace.useRef(void 0);
+    var merged = utilities.mergeOptions(options, execOptionsRef.current || {});
+    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 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) {
+            var method = obsQueryFields[key];
+            eagerMethods[key] = function () {
+                if (globalThis.__DEV__ !== false) {
+                    if (key === "reobserve") {
+                        globalThis.__DEV__ !== false && invariant.warn(69);
+                    }
+                }
+                if (!execOptionsRef.current) {
+                    execOptionsRef.current = Object.create(null);
+                    forceUpdateState();
+                }
+                return method.apply(this, arguments);
+            };
+        };
+        for (var _i = 0, EAGER_METHODS_1 = EAGER_METHODS; _i < EAGER_METHODS_1.length; _i++) {
+            var key = EAGER_METHODS_1[_i];
+            _loop_1(key);
+        }
+        return eagerMethods;
+    }, [forceUpdateState, obsQueryFields]);
+    var called = !!execOptionsRef.current;
+    var result = React__namespace.useMemo(function () { return (tslib.__assign(tslib.__assign(tslib.__assign({}, useQueryResult), eagerMethods), { called: called })); }, [useQueryResult, eagerMethods, called]);
+    var calledDuringRender = useRenderGuard();
+    var warnRef = React__namespace.useRef(new Set());
+    var execute = React__namespace.useCallback(function (executeOptions) {
+        if (globalThis.__DEV__ !== false) {
+            if (calledDuringRender()) {
+                globalThis.__DEV__ !== false && invariant.warn(70);
+            }
+            for (var _i = 0, REMOVED_EXECUTE_OPTIONS_1 = REMOVED_EXECUTE_OPTIONS; _i < REMOVED_EXECUTE_OPTIONS_1.length; _i++) {
+                var name_1 = REMOVED_EXECUTE_OPTIONS_1[_i];
+                if (!warnRef.current.has(name_1)) {
+                    warnRemovedOption(executeOptions || {}, name_1, "useLazyQuery.execute");
+                    warnRef.current.add(name_1);
+                }
+            }
+            for (var _a = 0, DEPRECATED_EXECUTE_OPTIONS_1 = DEPRECATED_EXECUTE_OPTIONS; _a < DEPRECATED_EXECUTE_OPTIONS_1.length; _a++) {
+                var name_2 = DEPRECATED_EXECUTE_OPTIONS_1[_a];
+                if (!warnRef.current.has(name_2)) {
+                    warnRemovedOption(executeOptions || {}, name_2, "useLazyQuery.execute", "Please pass the option to the `useLazyQuery` hook instead.");
+                    warnRef.current.add(name_2);
+                }
+            }
+        }
+        execOptionsRef.current =
+            executeOptions ? tslib.__assign(tslib.__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
+                fetchPolicy: initialFetchPolicy,
+            };
+        var options = utilities.mergeOptions(optionsRef.current, tslib.__assign({ query: queryRef.current }, execOptionsRef.current));
+        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;
+    }, [
+        calledDuringRender,
+        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(observable["maskResult"](result), resultData.previousData, observable, client));
+            },
+        });
+    });
+}
+
+function useMutation(mutation, options) {
+    if (globalThis.__DEV__ !== false) {
+        useWarnRemovedOption(options || {}, "ignoreResults", "useMutation", "If you don't want to synchronize component state with the mutation, please use the `useApolloClient` hook to get the client instance and call `client.mutate` directly.");
+    }
+    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
+    parser.verifyDocumentType(mutation, parser.DocumentType.Mutation);
+    var _a = React__namespace.useState({
+        called: false,
+        loading: false,
+        client: client,
+    }), result = _a[0], setResult = _a[1];
+    var ref = React__namespace.useRef({
+        result: result,
+        mutationId: 0,
+        isMounted: true,
+        client: client,
+        mutation: mutation,
+        options: options,
+    });
+    useIsomorphicLayoutEffect(function () {
+        Object.assign(ref.current, { client: client, options: options, mutation: mutation });
+    });
+    var execute = React__namespace.useCallback(function (executeOptions) {
+        if (executeOptions === void 0) { executeOptions = {}; }
+        var _a = ref.current, options = _a.options, mutation = _a.mutation;
+        var baseOptions = tslib.__assign(tslib.__assign({}, options), { mutation: mutation });
+        var client = executeOptions.client || ref.current.client;
+        if (!ref.current.result.loading &&
+            !baseOptions.ignoreResults &&
+            ref.current.isMounted) {
+            setResult((ref.current.result = {
+                loading: true,
+                error: void 0,
+                data: void 0,
+                called: true,
+                client: client,
+            }));
+        }
+        var mutationId = ++ref.current.mutationId;
+        var clientOptions = utilities.mergeOptions(baseOptions, executeOptions);
+        return client
+            .mutate(clientOptions)
+            .then(function (response) {
+            var _a, _b;
+            var data = response.data, errors$1 = response.errors;
+            var error = errors$1 && errors$1.length > 0 ?
+                new errors.ApolloError({ graphQLErrors: errors$1 })
+                : void 0;
+            var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);
+            if (error && onError) {
+                onError(error, clientOptions);
+            }
+            if (mutationId === ref.current.mutationId &&
+                !clientOptions.ignoreResults) {
+                var result_1 = {
+                    called: true,
+                    loading: false,
+                    data: data,
+                    error: error,
+                    client: client,
+                };
+                if (ref.current.isMounted && !equal.equal(ref.current.result, result_1)) {
+                    setResult((ref.current.result = result_1));
+                }
+            }
+            var onCompleted = executeOptions.onCompleted || ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onCompleted);
+            if (!error) {
+                onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response.data, clientOptions);
+            }
+            return response;
+        }, function (error) {
+            var _a;
+            if (mutationId === ref.current.mutationId &&
+                ref.current.isMounted) {
+                var result_2 = {
+                    loading: false,
+                    error: error,
+                    data: void 0,
+                    called: true,
+                    client: client,
+                };
+                if (!equal.equal(ref.current.result, result_2)) {
+                    setResult((ref.current.result = result_2));
+                }
+            }
+            var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);
+            if (onError) {
+                onError(error, clientOptions);
+                return { data: void 0, errors: error };
+            }
+            throw error;
+        });
+    }, []);
+    var reset = React__namespace.useCallback(function () {
+        if (ref.current.isMounted) {
+            var result_3 = {
+                called: false,
+                loading: false,
+                client: ref.current.client,
+            };
+            Object.assign(ref.current, { mutationId: 0, result: result_3 });
+            setResult(result_3);
+        }
+    }, []);
+    React__namespace.useEffect(function () {
+        var current = ref.current;
+        current.isMounted = true;
+        return function () {
+            current.isMounted = false;
+        };
+    }, []);
+    return [execute, tslib.__assign({ reset: reset }, result)];
+}
+
+function useSubscription(subscription, options) {
+    if (options === void 0) { options = Object.create(null); }
+    var hasIssuedDeprecationWarningRef = React__namespace.useRef(false);
+    var client = useApolloClient(options.client);
+    parser.verifyDocumentType(subscription, parser.DocumentType.Subscription);
+    if (!hasIssuedDeprecationWarningRef.current) {
+        hasIssuedDeprecationWarningRef.current = true;
+        if (options.onSubscriptionData) {
+            globalThis.__DEV__ !== false && globals.invariant.warn(options.onData ? 74 : 75);
+        }
+        if (options.onSubscriptionComplete) {
+            globalThis.__DEV__ !== false && globals.invariant.warn(options.onComplete ? 76 : 77);
+        }
+    }
+    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 function () { };
+        }
+        var subscriptionStopped = false;
+        var variables = observable.__.variables;
+        var client = observable.__.client;
+        var subscription = observable.subscribe({
+            next: function (fetchResult) {
+                var _a, _b;
+                if (subscriptionStopped) {
+                    return;
+                }
+                var result = {
+                    loading: false,
+                    data: fetchResult.data,
+                    error: toApolloError$1(fetchResult),
+                    variables: variables,
+                };
+                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 (optionsRef.current.onSubscriptionData) {
+                    optionsRef.current.onSubscriptionData({
+                        client: client,
+                        subscriptionData: result,
+                    });
+                }
+            },
+            error: function (error) {
+                var _a, _b;
+                error =
+                    error instanceof core.ApolloError ? error : (new core.ApolloError({ protocolErrors: [error] }));
+                if (!subscriptionStopped) {
+                    observable.__.setResult({
+                        loading: false,
+                        data: void 0,
+                        error: error,
+                        variables: variables,
+                    });
+                    if (!ignoreResultsRef.current)
+                        update();
+                    (_b = (_a = optionsRef.current).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+                }
+            },
+            complete: function () {
+                if (!subscriptionStopped) {
+                    if (optionsRef.current.onComplete) {
+                        optionsRef.current.onComplete();
+                    }
+                    else if (optionsRef.current.onSubscriptionComplete) {
+                        optionsRef.current.onSubscriptionComplete();
+                    }
+                }
+            },
+        });
+        return function () {
+            subscriptionStopped = true;
+            setTimeout(function () {
+                subscription.unsubscribe();
+            });
+        };
+    }, [observable]), function () {
+        return observable && !skip && !ignoreResults ?
+            observable.__.result
+            : fallbackResult;
+    }, function () { return fallbackResult; });
+    var restart = React__namespace.useCallback(function () {
+        globals.invariant(!optionsRef.current.skip, 78);
+        setObservable(recreateRef.current());
+    }, [optionsRef, recreateRef]);
+    return React__namespace.useMemo(function () { return (tslib.__assign(tslib.__assign({}, ret), { restart: restart })); }, [ret, restart]);
+}
+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) {
+    return useSyncExternalStore(React__namespace.useCallback(function (update) {
+        return rv.onNextChange(function onNext() {
+            update();
+            rv.onNextChange(onNext);
+        });
+    }, [rv]), rv, rv);
+}
+
+function useFragment(options) {
+    return wrapHook("useFragment",
+    useFragment_, useApolloClient(options.client))(options);
+}
+function useFragment_(options) {
+    if (globalThis.__DEV__ !== false) {
+        useWarnRemovedOption(options, "canonizeResults", "useFragment");
+    }
+    var client = useApolloClient(options.client);
+    var cache = client.cache;
+    var from = options.from, rest = tslib.__rest(options, ["from"]);
+    var id = React__namespace.useMemo(function () {
+        return typeof from === "string" ? from
+            : from === null ? null
+                : cache.identify(from);
+    }, [cache, from]);
+    var stableOptions = useDeepMemo(function () { return (tslib.__assign(tslib.__assign({}, rest), { from: id })); }, [rest, id]);
+    var diff = React__namespace.useMemo(function () {
+        var fragment = stableOptions.fragment, fragmentName = stableOptions.fragmentName, from = stableOptions.from, _a = stableOptions.optimistic, optimistic = _a === void 0 ? true : _a;
+        if (from === null) {
+            return {
+                result: diffToResult({
+                    result: {},
+                    complete: false,
+                }),
+            };
+        }
+        var cache = client.cache;
+        var diff = muteDeprecations("canonizeResults", function () {
+            return cache.diff(tslib.__assign(tslib.__assign({}, stableOptions), { returnPartialData: true, id: from, query: cache["getFragmentDoc"](fragment, fragmentName), optimistic: optimistic }));
+        });
+        return {
+            result: diffToResult(tslib.__assign(tslib.__assign({}, diff), { result: client["queryManager"].maskFragment({
+                    fragment: fragment,
+                    fragmentName: fragmentName,
+                    data: diff.result,
+                }) })),
+        };
+    }, [client, stableOptions]);
+    var getSnapshot = React__namespace.useCallback(function () { return diff.result; }, [diff]);
+    return useSyncExternalStore(React__namespace.useCallback(function (forceUpdate) {
+        var lastTimeout = 0;
+        var subscription = muteDeprecations("canonizeResults", function () {
+            return stableOptions.from === null ?
+                null
+                : client.watchFragment(stableOptions).subscribe({
+                    next: function (result) {
+                        if (equal__default(result, diff.result))
+                            return;
+                        diff.result = result;
+                        clearTimeout(lastTimeout);
+                        lastTimeout = setTimeout(forceUpdate);
+                    },
+                });
+        });
+        return function () {
+            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+            clearTimeout(lastTimeout);
+        };
+    }, [client, stableOptions, diff]), getSnapshot, getSnapshot);
+}
+function diffToResult(diff) {
+    var result = {
+        data: diff.result,
+        complete: !!diff.complete,
+    };
+    if (diff.missing) {
+        result.missing = utilities.mergeDeepArray(diff.missing.map(function (error) { return error.missing; }));
+    }
+    return result;
+}
+
+var skipToken = Symbol.for("apollo.skipToken");
+
+function useSuspenseQuery(query, options) {
+    if (options === void 0) { options = Object.create(null); }
+    return wrapHook("useSuspenseQuery",
+    useSuspenseQuery_, useApolloClient(typeof options === "object" ? options.client : undefined))(query, options);
+}
+function useSuspenseQuery_(query, options) {
+    if (globalThis.__DEV__ !== false) {
+        useWarnRemovedOption(typeof options === "symbol" ? {} : options, "canonizeResults", "useSuspenseQuery");
+    }
+    var client = useApolloClient(options.client);
+    var suspenseCache = internal.getSuspenseCache(client);
+    var watchQueryOptions = useWatchQueryOptions({
+        client: client,
+        query: query,
+        options: options,
+    });
+    var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;
+    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
+    var cacheKey = tslib.__spreadArray([
+        query,
+        cache.canonicalStringify(variables)
+    ], [].concat(queryKey), true);
+    var queryRef = muteDeprecations("canonizeResults", function () {
+        return suspenseCache.getQueryRef(cacheKey, function () {
+            return client.watchQuery(watchQueryOptions);
+        });
+    });
+    var _b = React__namespace.useState([queryRef.key, queryRef.promise]), current = _b[0], setPromise = _b[1];
+    if (current[0] !== queryRef.key) {
+        current[0] = queryRef.key;
+        current[1] = queryRef.promise;
+    }
+    var promise = current[1];
+    if (queryRef.didChangeOptions(watchQueryOptions)) {
+        current[1] = promise = queryRef.applyOptions(watchQueryOptions);
+    }
+    React__namespace.useEffect(function () {
+        var dispose = queryRef.retain();
+        var removeListener = queryRef.listen(function (promise) {
+            setPromise([queryRef.key, promise]);
+        });
+        return function () {
+            removeListener();
+            dispose();
+        };
+    }, [queryRef]);
+    var skipResult = React__namespace.useMemo(function () {
+        var error = toApolloError(queryRef.result);
+        return {
+            loading: false,
+            data: queryRef.result.data,
+            networkStatus: error ? core.NetworkStatus.error : core.NetworkStatus.ready,
+            error: error,
+        };
+    }, [queryRef.result]);
+    var result = fetchPolicy === "standby" ? skipResult : __use(promise);
+    var fetchMore = React__namespace.useCallback(function (options) {
+        var promise = queryRef.fetchMore(options);
+        setPromise([queryRef.key, queryRef.promise]);
+        return promise;
+    }, [queryRef]);
+    var refetch = React__namespace.useCallback(function (variables) {
+        var promise = queryRef.refetch(variables);
+        setPromise([queryRef.key, queryRef.promise]);
+        return promise;
+    }, [queryRef]);
+    var subscribeToMore = queryRef.observable
+        .subscribeToMore;
+    return React__namespace.useMemo(function () {
+        return {
+            client: client,
+            data: result.data,
+            error: toApolloError(result),
+            networkStatus: result.networkStatus,
+            fetchMore: fetchMore,
+            refetch: refetch,
+            subscribeToMore: subscribeToMore,
+        };
+    }, [client, fetchMore, refetch, result, subscribeToMore]);
+}
+function validateOptions(options) {
+    var query = options.query, fetchPolicy = options.fetchPolicy, returnPartialData = options.returnPartialData;
+    parser.verifyDocumentType(query, parser.DocumentType.Query);
+    validateFetchPolicy(fetchPolicy);
+    validatePartialDataReturn(fetchPolicy, returnPartialData);
+}
+function validateFetchPolicy(fetchPolicy) {
+    if (fetchPolicy === void 0) { fetchPolicy = "cache-first"; }
+    var supportedFetchPolicies = [
+        "cache-first",
+        "network-only",
+        "no-cache",
+        "cache-and-network",
+    ];
+    globals.invariant(supportedFetchPolicies.includes(fetchPolicy), 79, fetchPolicy);
+}
+function validatePartialDataReturn(fetchPolicy, returnPartialData) {
+    if (fetchPolicy === "no-cache" && returnPartialData) {
+        globalThis.__DEV__ !== false && globals.invariant.warn(80);
+    }
+}
+function toApolloError(result) {
+    return utilities.isNonEmptyArray(result.errors) ?
+        new core.ApolloError({ graphQLErrors: result.errors })
+        : result.error;
+}
+function useWatchQueryOptions(_a) {
+    var client = _a.client, query = _a.query, options = _a.options;
+    return useDeepMemo(function () {
+        var _a;
+        if (options === skipToken) {
+            return { query: query, fetchPolicy: "standby" };
+        }
+        var fetchPolicy = options.fetchPolicy ||
+            ((_a = client.defaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||
+            "cache-first";
+        var watchQueryOptions = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: fetchPolicy, query: query, notifyOnNetworkStatusChange: false, nextFetchPolicy: void 0 });
+        if (globalThis.__DEV__ !== false) {
+            validateOptions(watchQueryOptions);
+        }
+        if (options.skip) {
+            watchQueryOptions.fetchPolicy = "standby";
+        }
+        return watchQueryOptions;
+    }, [client, options, query]);
+}
+
+function useBackgroundQuery(query, options) {
+    if (options === void 0) { options = Object.create(null); }
+    return wrapHook("useBackgroundQuery",
+    useBackgroundQuery_, useApolloClient(typeof options === "object" ? options.client : undefined))(query, options);
+}
+function useBackgroundQuery_(query, options) {
+    if (globalThis.__DEV__ !== false) {
+        useWarnRemovedOption(typeof options === "symbol" ? {} : options, "canonizeResults", "useBackgroundQuery");
+    }
+    var client = useApolloClient(options.client);
+    var suspenseCache = internal.getSuspenseCache(client);
+    var watchQueryOptions = useWatchQueryOptions({ client: client, query: query, options: options });
+    var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;
+    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
+    var didFetchResult = React__namespace.useRef(fetchPolicy !== "standby");
+    didFetchResult.current || (didFetchResult.current = fetchPolicy !== "standby");
+    var cacheKey = tslib.__spreadArray([
+        query,
+        cache.canonicalStringify(variables)
+    ], [].concat(queryKey), true);
+    var queryRef = muteDeprecations("canonizeResults", function () {
+        return suspenseCache.getQueryRef(cacheKey, function () {
+            return client.watchQuery(watchQueryOptions);
+        });
+    });
+    var _b = React__namespace.useState(internal.wrapQueryRef(queryRef)), wrappedQueryRef = _b[0], setWrappedQueryRef = _b[1];
+    if (internal.unwrapQueryRef(wrappedQueryRef) !== queryRef) {
+        setWrappedQueryRef(internal.wrapQueryRef(queryRef));
+    }
+    if (queryRef.didChangeOptions(watchQueryOptions)) {
+        var promise = queryRef.applyOptions(watchQueryOptions);
+        internal.updateWrappedQueryRef(wrappedQueryRef, promise);
+    }
+    React__namespace.useEffect(function () {
+        var id = setTimeout(function () {
+            if (queryRef.disposed) {
+                suspenseCache.add(cacheKey, queryRef);
+            }
+        });
+        return function () { return clearTimeout(id); };
+    });
+    var fetchMore = React__namespace.useCallback(function (options) {
+        var promise = queryRef.fetchMore(options);
+        setWrappedQueryRef(internal.wrapQueryRef(queryRef));
+        return promise;
+    }, [queryRef]);
+    var refetch = React__namespace.useCallback(function (variables) {
+        var promise = queryRef.refetch(variables);
+        setWrappedQueryRef(internal.wrapQueryRef(queryRef));
+        return promise;
+    }, [queryRef]);
+    React__namespace.useEffect(function () { return queryRef.softRetain(); }, [queryRef]);
+    return [
+        didFetchResult.current ? wrappedQueryRef : void 0,
+        {
+            fetchMore: fetchMore,
+            refetch: refetch,
+            subscribeToMore: queryRef.observable
+                .subscribeToMore,
+        },
+    ];
+}
+
+var NULL_PLACEHOLDER = [];
+function useSuspenseFragment(options) {
+    return wrapHook("useSuspenseFragment",
+    useSuspenseFragment_, useApolloClient(typeof options === "object" ? options.client : undefined))(options);
+}
+function useSuspenseFragment_(options) {
+    var client = useApolloClient(options.client);
+    var from = options.from, variables = options.variables;
+    var cache$1 = client.cache;
+    var id = React__namespace.useMemo(function () {
+        return typeof from === "string" ? from
+            : from === null ? null
+                : cache$1.identify(from);
+    }, [cache$1, from]);
+    var fragmentRef = id === null ? null : (internal.getSuspenseCache(client).getFragmentRef([id, options.fragment, cache.canonicalStringify(variables)], client, tslib.__assign(tslib.__assign({}, options), { variables: variables, from: id })));
+    var _a = React__namespace.useState(fragmentRef === null ? NULL_PLACEHOLDER : ([fragmentRef.key, fragmentRef.promise])), current = _a[0], setPromise = _a[1];
+    React__namespace.useEffect(function () {
+        if (fragmentRef === null) {
+            return;
+        }
+        var dispose = fragmentRef.retain();
+        var removeListener = fragmentRef.listen(function (promise) {
+            setPromise([fragmentRef.key, promise]);
+        });
+        return function () {
+            dispose();
+            removeListener();
+        };
+    }, [fragmentRef]);
+    if (fragmentRef === null) {
+        return { data: null };
+    }
+    if (current[0] !== fragmentRef.key) {
+        current[0] = fragmentRef.key;
+        current[1] = fragmentRef.promise;
+    }
+    var data = __use(current[1]);
+    return { data: data };
+}
+
+function useLoadableQuery(query, options) {
+    if (options === void 0) { options = Object.create(null); }
+    if (globalThis.__DEV__ !== false) {
+        useWarnRemovedOption(options, "canonizeResults", "useLoadableQuery");
+    }
+    var client = useApolloClient(options.client);
+    var suspenseCache = internal.getSuspenseCache(client);
+    var watchQueryOptions = useWatchQueryOptions({ client: client, query: query, options: options });
+    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
+    var _b = React__namespace.useState(null), queryRef = _b[0], setQueryRef = _b[1];
+    internal.assertWrappedQueryRef(queryRef);
+    var internalQueryRef = queryRef && internal.unwrapQueryRef(queryRef);
+    if (queryRef && (internalQueryRef === null || internalQueryRef === void 0 ? void 0 : internalQueryRef.didChangeOptions(watchQueryOptions))) {
+        var promise = internalQueryRef.applyOptions(watchQueryOptions);
+        internal.updateWrappedQueryRef(queryRef, promise);
+    }
+    var calledDuringRender = useRenderGuard();
+    var fetchMore = React__namespace.useCallback(function (options) {
+        if (!internalQueryRef) {
+            throw new Error("The query has not been loaded. Please load the query.");
+        }
+        var promise = internalQueryRef.fetchMore(options);
+        setQueryRef(internal.wrapQueryRef(internalQueryRef));
+        return promise;
+    }, [internalQueryRef]);
+    var refetch = React__namespace.useCallback(function (options) {
+        if (!internalQueryRef) {
+            throw new Error("The query has not been loaded. Please load the query.");
+        }
+        var promise = internalQueryRef.refetch(options);
+        setQueryRef(internal.wrapQueryRef(internalQueryRef));
+        return promise;
+    }, [internalQueryRef]);
+    var loadQuery = React__namespace.useCallback(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        globals.invariant(!calledDuringRender(), 71);
+        var variables = args[0];
+        var cacheKey = tslib.__spreadArray([
+            query,
+            cache.canonicalStringify(variables)
+        ], [].concat(queryKey), true);
+        var queryRef = muteDeprecations("canonizeResults", function () {
+            return suspenseCache.getQueryRef(cacheKey, function () {
+                return client.watchQuery(tslib.__assign(tslib.__assign({}, watchQueryOptions), { variables: variables }));
+            });
+        });
+        setQueryRef(internal.wrapQueryRef(queryRef));
+    }, [
+        query,
+        queryKey,
+        suspenseCache,
+        watchQueryOptions,
+        calledDuringRender,
+        client,
+    ]);
+    var subscribeToMore = React__namespace.useCallback(function (options) {
+        globals.invariant(internalQueryRef, 72);
+        return internalQueryRef.observable.subscribeToMore(
+        options);
+    }, [internalQueryRef]);
+    var reset = React__namespace.useCallback(function () {
+        setQueryRef(null);
+    }, []);
+    return [loadQuery, queryRef, { fetchMore: fetchMore, refetch: refetch, reset: reset, subscribeToMore: subscribeToMore }];
+}
+
+function useQueryRefHandlers(queryRef) {
+    var unwrapped = internal.unwrapQueryRef(queryRef);
+    var clientOrObsQuery = useApolloClient(unwrapped ?
+        unwrapped["observable"]
+        : undefined);
+    return wrapHook("useQueryRefHandlers",
+    useQueryRefHandlers_, clientOrObsQuery)(queryRef);
+}
+function useQueryRefHandlers_(queryRef) {
+    internal.assertWrappedQueryRef(queryRef);
+    var _a = React__namespace.useState(queryRef), previousQueryRef = _a[0], setPreviousQueryRef = _a[1];
+    var _b = React__namespace.useState(queryRef), wrappedQueryRef = _b[0], setWrappedQueryRef = _b[1];
+    var internalQueryRef = internal.unwrapQueryRef(queryRef);
+    if (previousQueryRef !== queryRef) {
+        setPreviousQueryRef(queryRef);
+        setWrappedQueryRef(queryRef);
+    }
+    else {
+        internal.updateWrappedQueryRef(queryRef, internal.getWrappedPromise(wrappedQueryRef));
+    }
+    var refetch = React__namespace.useCallback(function (variables) {
+        var promise = internalQueryRef.refetch(variables);
+        setWrappedQueryRef(internal.wrapQueryRef(internalQueryRef));
+        return promise;
+    }, [internalQueryRef]);
+    var fetchMore = React__namespace.useCallback(function (options) {
+        var promise = internalQueryRef.fetchMore(options);
+        setWrappedQueryRef(internal.wrapQueryRef(internalQueryRef));
+        return promise;
+    }, [internalQueryRef]);
+    return {
+        refetch: refetch,
+        fetchMore: fetchMore,
+        subscribeToMore: internalQueryRef.observable
+            .subscribeToMore,
+    };
+}
+
+function useReadQuery(queryRef) {
+    var unwrapped = internal.unwrapQueryRef(queryRef);
+    var clientOrObsQuery = useApolloClient(unwrapped ?
+        unwrapped["observable"]
+        : undefined);
+    return wrapHook("useReadQuery",
+    useReadQuery_, clientOrObsQuery)(queryRef);
+}
+function useReadQuery_(queryRef) {
+    internal.assertWrappedQueryRef(queryRef);
+    var internalQueryRef = React__namespace.useMemo(function () { return internal.unwrapQueryRef(queryRef); }, [queryRef]);
+    var getPromise = React__namespace.useCallback(function () { return internal.getWrappedPromise(queryRef); }, [queryRef]);
+    if (internalQueryRef.disposed) {
+        internalQueryRef.reinitialize();
+        internal.updateWrappedQueryRef(queryRef, internalQueryRef.promise);
+    }
+    React__namespace.useEffect(function () { return internalQueryRef.retain(); }, [internalQueryRef]);
+    var promise = useSyncExternalStore(React__namespace.useCallback(function (forceUpdate) {
+        return internalQueryRef.listen(function (promise) {
+            internal.updateWrappedQueryRef(queryRef, promise);
+            forceUpdate();
+        });
+    }, [internalQueryRef, queryRef]), getPromise, getPromise);
+    var result = __use(promise);
+    return React__namespace.useMemo(function () {
+        return {
+            data: result.data,
+            networkStatus: result.networkStatus,
+            error: toApolloError(result),
+        };
+    }, [result]);
+}
+
+exports.skipToken = skipToken;
+exports.useApolloClient = useApolloClient;
+exports.useBackgroundQuery = useBackgroundQuery;
+exports.useFragment = useFragment;
+exports.useLazyQuery = useLazyQuery;
+exports.useLoadableQuery = useLoadableQuery;
+exports.useMutation = useMutation;
+exports.useQuery = useQuery;
+exports.useQueryRefHandlers = useQueryRefHandlers;
+exports.useReactiveVar = useReactiveVar;
+exports.useReadQuery = useReadQuery;
+exports.useSubscription = useSubscription;
+exports.useSuspenseFragment = useSuspenseFragment;
+exports.useSuspenseQuery = useSuspenseQuery;
+//# sourceMappingURL=hooks.cjs.map