{"version":3,"file":"static/chunks/6418-0561e86d6eb549ba.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@apollo/client/core/networkStatus.js","webpack://_N_E/./node_modules/@apollo/client/react/hooks/useSyncExternalStore.js","webpack://_N_E/./node_modules/@apollo/client/react/hooks/internal/wrapHook.js","webpack://_N_E/./node_modules/@apollo/client/react/hooks/useQuery.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/arrays.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/maybeDeepFreeze.js","webpack://_N_E/<anon>"],"sourcesContent":["/**\n * The current status of a query’s execution in our system.\n */\nexport var NetworkStatus;\n(function (NetworkStatus) {\n    /**\n     * The query has never been run before and the query is now currently running. A query will still\n     * have this network status even if a partial data result was returned from the cache, but a\n     * query was dispatched anyway.\n     */\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    /**\n     * If `setVariables` was called and a query was fired because of that then the network status\n     * will be `setVariables` until the result of that query comes back.\n     */\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    /**\n     * Indicates that `fetchMore` was called on this query and that the query created is currently in\n     * flight.\n     */\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    /**\n     * Similar to the `setVariables` network status. It means that `refetch` was called on a query\n     * and the refetch request is currently in flight.\n     */\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    /**\n     * Indicates that a polling query is currently in flight. So for example if you are polling a\n     * query every 10 seconds then the network status will switch to `poll` every 10 seconds whenever\n     * a poll request has been sent but not resolved.\n     */\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    /**\n     * No request is in flight for this query, and no errors happened. Everything is OK.\n     */\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    /**\n     * No request is in flight for this query, but one or more errors were detected.\n     */\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n})(NetworkStatus || (NetworkStatus = {}));\n/**\n * Returns true if there is currently a network request in flight according to a given network\n * status.\n */\nexport function isNetworkRequestInFlight(networkStatus) {\n    return networkStatus ? networkStatus < 7 : false;\n}\n/**\n * Returns true if the network request is in ready or error state according to a given network\n * status.\n */\nexport function isNetworkRequestSettled(networkStatus) {\n    return networkStatus === 7 || networkStatus === 8;\n}\n//# sourceMappingURL=networkStatus.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from \"rehackt\";\nimport { canUseLayoutEffect } from \"../../utilities/index.js\";\nvar didWarnUncachedGetSnapshot = false;\n// Prevent webpack from complaining about our feature detection of the\n// useSyncExternalStore property of the React namespace, which is expected not\n// to exist when using React 17 and earlier, and that's fine.\nvar uSESKey = \"useSyncExternalStore\";\nvar realHook = React[uSESKey];\n// Adapted from https://www.npmjs.com/package/use-sync-external-store, with\n// Apollo Client deviations called out by \"// DEVIATION ...\" comments.\n// When/if React.useSyncExternalStore is defined, delegate fully to it.\nexport var useSyncExternalStore = realHook ||\n    (function (subscribe, getSnapshot, getServerSnapshot) {\n        // Read the current snapshot from the store on every render. Again, this\n        // breaks the rules of React, and only works here because of specific\n        // implementation details, most importantly that updates are\n        // always synchronous.\n        var value = getSnapshot();\n        if (\n        // DEVIATION: Using __DEV__\n        globalThis.__DEV__ !== false &&\n            !didWarnUncachedGetSnapshot &&\n            // DEVIATION: Not using Object.is because we know our snapshots will never\n            // be exotic primitive values like NaN, which is !== itself.\n            value !== getSnapshot()) {\n            didWarnUncachedGetSnapshot = true;\n            // DEVIATION: Using invariant.error instead of console.error directly.\n            globalThis.__DEV__ !== false && invariant.error(60);\n        }\n        // Because updates are synchronous, we don't queue them. Instead we force a\n        // re-render whenever the subscribed state changes by updating an some\n        // arbitrary useState hook. Then, during render, we call getSnapshot to read\n        // the current value.\n        //\n        // Because we don't actually use the state returned by the useState hook, we\n        // can save a bit of memory by storing other stuff in that slot.\n        //\n        // To implement the early bailout, we need to track some things on a mutable\n        // object. Usually, we would put that in a useRef hook, but we can stash it in\n        // our useState hook instead.\n        //\n        // To force a re-render, we call forceUpdate({inst}). That works because the\n        // new object always fails an equality check.\n        var _a = React.useState({\n            inst: { value: value, getSnapshot: getSnapshot },\n        }), inst = _a[0].inst, forceUpdate = _a[1];\n        // Track the latest getSnapshot function with a ref. This needs to be updated\n        // in the layout phase so we can access it during the tearing check that\n        // happens on subscribe.\n        if (canUseLayoutEffect) {\n            // DEVIATION: We avoid calling useLayoutEffect when !canUseLayoutEffect,\n            // which may seem like a conditional hook, but this code ends up behaving\n            // unconditionally (one way or the other) because canUseLayoutEffect is\n            // constant.\n            React.useLayoutEffect(function () {\n                Object.assign(inst, { value: value, getSnapshot: getSnapshot });\n                // Whenever getSnapshot or subscribe changes, we need to check in the\n                // commit phase if there was an interleaved mutation. In concurrent mode\n                // this can happen all the time, but even in synchronous mode, an earlier\n                // effect may have mutated the store.\n                if (checkIfSnapshotChanged(inst)) {\n                    // Force a re-render.\n                    forceUpdate({ inst: inst });\n                }\n                // React Hook React.useLayoutEffect has a missing dependency: 'inst'. Either include it or remove the dependency array.\n                // eslint-disable-next-line react-hooks/exhaustive-deps\n            }, [subscribe, value, getSnapshot]);\n        }\n        else {\n            Object.assign(inst, { value: value, getSnapshot: getSnapshot });\n        }\n        React.useEffect(function () {\n            // Check for changes right before subscribing. Subsequent changes will be\n            // detected in the subscription handler.\n            if (checkIfSnapshotChanged(inst)) {\n                // Force a re-render.\n                forceUpdate({ inst: inst });\n            }\n            // Subscribe to the store and return a clean-up function.\n            return subscribe(function handleStoreChange() {\n                // TODO: Because there is no cross-renderer API for batching updates, it's\n                // up to the consumer of this library to wrap their subscription event\n                // with unstable_batchedUpdates. Should we try to detect when this isn't\n                // the case and print a warning in development?\n                // The store changed. Check if the snapshot changed since the last time we\n                // read from the store.\n                if (checkIfSnapshotChanged(inst)) {\n                    // Force a re-render.\n                    forceUpdate({ inst: inst });\n                }\n            });\n            // React Hook React.useEffect has a missing dependency: 'inst'. Either include it or remove the dependency array.\n            // eslint-disable-next-line react-hooks/exhaustive-deps\n        }, [subscribe]);\n        return value;\n    });\nfunction checkIfSnapshotChanged(_a) {\n    var value = _a.value, getSnapshot = _a.getSnapshot;\n    try {\n        return value !== getSnapshot();\n    }\n    catch (_b) {\n        return true;\n    }\n}\n//# sourceMappingURL=useSyncExternalStore.js.map","var wrapperSymbol = Symbol.for(\"apollo.hook.wrappers\");\n/**\n * @internal\n *\n * Makes an Apollo Client hook \"wrappable\".\n * That means that the Apollo Client instance can expose a \"wrapper\" that will be\n * used to wrap the original hook implementation with additional logic.\n * @example\n * ```tsx\n * // this is already done in `@apollo/client` for all wrappable hooks (see `WrappableHooks`)\n * // following this pattern\n * function useQuery() {\n *   return wrapHook('useQuery', _useQuery, options.client)(query, options);\n * }\n * function _useQuery(query, options) {\n *   // original implementation\n * }\n *\n * // this is what a library like `@apollo/client-react-streaming` would do\n * class ApolloClientWithStreaming extends ApolloClient {\n *   constructor(options) {\n *     super(options);\n *     this.queryManager[Symbol.for(\"apollo.hook.wrappers\")] = {\n *       useQuery: (original) => (query, options) => {\n *         console.log(\"useQuery was called with options\", options);\n *         return original(query, options);\n *       }\n *     }\n *   }\n * }\n *\n * // this will now log the options and then call the original `useQuery`\n * const client = new ApolloClientWithStreaming({ ... });\n * useQuery(query, { client });\n * ```\n */\nexport function wrapHook(hookName, useHook, clientOrObsQuery) {\n    var queryManager = clientOrObsQuery[\"queryManager\"];\n    var wrappers = queryManager && queryManager[wrapperSymbol];\n    var wrapper = wrappers && wrappers[hookName];\n    return wrapper ? wrapper(useHook) : useHook;\n}\n//# sourceMappingURL=wrapHook.js.map","import { __assign, __rest } from \"tslib\";\n/**\n * Function parameters in this file try to follow a common order for the sake of\n * readability and consistency. The order is as follows:\n *\n * resultData\n * observable\n * client\n * query\n * options\n * watchQueryOptions\n * makeWatchQueryOptions\n * isSSRAllowed\n * disableNetworkFetches\n * partialRefetch\n * renderPromises\n * isSyncSSR\n * callbacks\n */\n/** */\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from \"rehackt\";\nimport { useSyncExternalStore } from \"./useSyncExternalStore.js\";\nimport { equal } from \"@wry/equality\";\nimport { mergeOptions } from \"../../utilities/index.js\";\nimport { getApolloContext } from \"../context/index.js\";\nimport { ApolloError } from \"../../errors/index.js\";\nimport { NetworkStatus } from \"../../core/index.js\";\nimport { DocumentType, verifyDocumentType } from \"../parser/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nimport { compact, isNonEmptyArray, maybeDeepFreeze, } from \"../../utilities/index.js\";\nimport { wrapHook } from \"./internal/index.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction noop() { }\nexport var lastWatchOptions = Symbol();\n/**\n * A hook for executing queries in an Apollo application.\n *\n * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.\n *\n * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, and `data` properties you can use to render your UI.\n *\n * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.\n *\n * @example\n * ```jsx\n * import { gql, useQuery } from '@apollo/client';\n *\n * const GET_GREETING = gql`\n *   query GetGreeting($language: String!) {\n *     greeting(language: $language) {\n *       message\n *     }\n *   }\n * `;\n *\n * function Hello() {\n *   const { loading, error, data } = useQuery(GET_GREETING, {\n *     variables: { language: 'english' },\n *   });\n *   if (loading) return <p>Loading ...</p>;\n *   return <h1>Hello {data.greeting.message}!</h1>;\n * }\n * ```\n * @since 3.0.0\n * @param query - A GraphQL query document parsed into an AST by `gql`.\n * @param options - Options to control how the query is executed.\n * @returns Query result object\n */\nexport function useQuery(query, options) {\n    if (options === void 0) { options = Object.create(null); }\n    return wrapHook(\"useQuery\", _useQuery, useApolloClient(options && options.client))(query, options);\n}\nfunction _useQuery(query, options) {\n    var _a = useQueryInternals(query, options), result = _a.result, obsQueryFields = _a.obsQueryFields;\n    return React.useMemo(function () { return (__assign(__assign({}, result), obsQueryFields)); }, [result, obsQueryFields]);\n}\nfunction useInternalState(client, query, options, renderPromises, makeWatchQueryOptions) {\n    function createInternalState(previous) {\n        var _a;\n        verifyDocumentType(query, DocumentType.Query);\n        var internalState = {\n            client: client,\n            query: query,\n            observable: \n            // See if there is an existing observable that was used to fetch the same\n            // data and if so, use it instead since it will contain the proper queryId\n            // to fetch the result set. This is used during SSR.\n            (renderPromises &&\n                renderPromises.getSSRObservable(makeWatchQueryOptions())) ||\n                client.watchQuery(getObsQueryOptions(void 0, client, options, makeWatchQueryOptions())),\n            resultData: {\n                // Reuse previousData from previous InternalState (if any) to provide\n                // continuity of previousData even if/when the query or client changes.\n                previousData: (_a = previous === null || previous === void 0 ? void 0 : previous.resultData.current) === null || _a === void 0 ? void 0 : _a.data,\n            },\n        };\n        return internalState;\n    }\n    var _a = React.useState(createInternalState), internalState = _a[0], updateInternalState = _a[1];\n    /**\n     * Used by `useLazyQuery` when a new query is executed.\n     * We keep this logic here since it needs to update things in unsafe\n     * ways and here we at least can keep track of that in a single place.\n     */\n    function onQueryExecuted(watchQueryOptions) {\n        var _a;\n        var _b;\n        // this needs to be set to prevent an immediate `resubscribe` in the\n        // next rerender of the `useQuery` internals\n        Object.assign(internalState.observable, (_a = {},\n            _a[lastWatchOptions] = watchQueryOptions,\n            _a));\n        var resultData = internalState.resultData;\n        updateInternalState(__assign(__assign({}, internalState), { \n            // might be a different query\n            query: watchQueryOptions.query, resultData: Object.assign(resultData, {\n                // We need to modify the previous `resultData` object as we rely on the\n                // object reference in other places\n                previousData: ((_b = resultData.current) === null || _b === void 0 ? void 0 : _b.data) || resultData.previousData,\n                current: undefined,\n            }) }));\n    }\n    if (client !== internalState.client || query !== internalState.query) {\n        // If the client or query have changed, we need to create a new InternalState.\n        // This will trigger a re-render with the new state, but it will also continue\n        // to run the current render function to completion.\n        // Since we sometimes trigger some side-effects in the render function, we\n        // re-assign `state` to the new state to ensure that those side-effects are\n        // triggered with the new state.\n        var newInternalState = createInternalState(internalState);\n        updateInternalState(newInternalState);\n        return [newInternalState, onQueryExecuted];\n    }\n    return [internalState, onQueryExecuted];\n}\nexport function useQueryInternals(query, options) {\n    var client = useApolloClient(options.client);\n    var renderPromises = React.useContext(getApolloContext()).renderPromises;\n    var isSyncSSR = !!renderPromises;\n    var disableNetworkFetches = client.disableNetworkFetches;\n    var ssrAllowed = options.ssr !== false && !options.skip;\n    var partialRefetch = options.partialRefetch;\n    var makeWatchQueryOptions = createMakeWatchQueryOptions(client, query, options, isSyncSSR);\n    var _a = useInternalState(client, query, options, renderPromises, makeWatchQueryOptions), _b = _a[0], observable = _b.observable, resultData = _b.resultData, onQueryExecuted = _a[1];\n    var watchQueryOptions = makeWatchQueryOptions(observable);\n    useResubscribeIfNecessary(resultData, // might get mutated during render\n    observable, // might get mutated during render\n    client, options, watchQueryOptions);\n    var obsQueryFields = React.useMemo(function () { return bindObservableMethods(observable); }, [observable]);\n    useRegisterSSRObservable(observable, renderPromises, ssrAllowed);\n    var result = useObservableSubscriptionResult(resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, partialRefetch, isSyncSSR, {\n        onCompleted: options.onCompleted || noop,\n        onError: options.onError || noop,\n    });\n    return {\n        result: result,\n        obsQueryFields: obsQueryFields,\n        observable: observable,\n        resultData: resultData,\n        client: client,\n        onQueryExecuted: onQueryExecuted,\n    };\n}\nfunction useObservableSubscriptionResult(resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, partialRefetch, isSyncSSR, callbacks) {\n    var callbackRef = React.useRef(callbacks);\n    React.useEffect(function () {\n        // Make sure state.onCompleted and state.onError always reflect the latest\n        // options.onCompleted and options.onError callbacks provided to useQuery,\n        // since those functions are often recreated every time useQuery is called.\n        // Like the forceUpdate method, the versions of these methods inherited from\n        // InternalState.prototype are empty no-ops, but we can override them on the\n        // base state object (without modifying the prototype).\n        callbackRef.current = callbacks;\n    });\n    var resultOverride = ((isSyncSSR || disableNetworkFetches) &&\n        options.ssr === false &&\n        !options.skip) ?\n        // If SSR has been explicitly disabled, and this function has been called\n        // on the server side, return the default loading state.\n        ssrDisabledResult\n        : options.skip || watchQueryOptions.fetchPolicy === \"standby\" ?\n            // When skipping a query (ie. we're not querying for data but still want to\n            // render children), make sure the `data` is cleared out and `loading` is\n            // set to `false` (since we aren't loading anything).\n            //\n            // NOTE: We no longer think this is the correct behavior. Skipping should\n            // not automatically set `data` to `undefined`, but instead leave the\n            // previous data in place. In other words, skipping should not mandate that\n            // previously received data is all of a sudden removed. Unfortunately,\n            // changing this is breaking, so we'll have to wait until Apollo Client 4.0\n            // to address this.\n            skipStandbyResult\n            : void 0;\n    var previousData = resultData.previousData;\n    var currentResultOverride = React.useMemo(function () {\n        return resultOverride &&\n            toQueryResult(resultOverride, previousData, observable, client);\n    }, [client, observable, resultOverride, previousData]);\n    return useSyncExternalStore(React.useCallback(function (handleStoreChange) {\n        // reference `disableNetworkFetches` here to ensure that the rules of hooks\n        // keep it as a dependency of this effect, even though it's not used\n        disableNetworkFetches;\n        if (isSyncSSR) {\n            return function () { };\n        }\n        var onNext = function () {\n            var previousResult = resultData.current;\n            // We use `getCurrentResult()` instead of the onNext argument because\n            // the values differ slightly. Specifically, loading results will have\n            // an empty object for data instead of `undefined` for some reason.\n            var result = observable.getCurrentResult();\n            // Make sure we're not attempting to re-render similar results\n            if (previousResult &&\n                previousResult.loading === result.loading &&\n                previousResult.networkStatus === result.networkStatus &&\n                equal(previousResult.data, result.data)) {\n                return;\n            }\n            setResult(result, resultData, observable, client, partialRefetch, handleStoreChange, callbackRef.current);\n        };\n        var onError = function (error) {\n            subscription.current.unsubscribe();\n            subscription.current = observable.resubscribeAfterError(onNext, onError);\n            if (!hasOwnProperty.call(error, \"graphQLErrors\")) {\n                // The error is not a GraphQL error\n                throw error;\n            }\n            var previousResult = resultData.current;\n            if (!previousResult ||\n                (previousResult && previousResult.loading) ||\n                !equal(error, previousResult.error)) {\n                setResult({\n                    data: (previousResult && previousResult.data),\n                    error: error,\n                    loading: false,\n                    networkStatus: NetworkStatus.error,\n                }, resultData, observable, client, partialRefetch, handleStoreChange, callbackRef.current);\n            }\n        };\n        // TODO evaluate if we keep this in\n        // React Compiler cannot handle scoped `let` access, but a mutable object\n        // like this is fine.\n        // was:\n        // let subscription = observable.subscribe(onNext, onError);\n        var subscription = { current: observable.subscribe(onNext, onError) };\n        // Do the \"unsubscribe\" with a short delay.\n        // This way, an existing subscription can be reused without an additional\n        // request if \"unsubscribe\"  and \"resubscribe\" to the same ObservableQuery\n        // happen in very fast succession.\n        return function () {\n            setTimeout(function () { return subscription.current.unsubscribe(); });\n        };\n    }, [\n        disableNetworkFetches,\n        isSyncSSR,\n        observable,\n        resultData,\n        partialRefetch,\n        client,\n    ]), function () {\n        return currentResultOverride ||\n            getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);\n    }, function () {\n        return currentResultOverride ||\n            getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);\n    });\n}\nfunction useRegisterSSRObservable(observable, renderPromises, ssrAllowed) {\n    if (renderPromises && ssrAllowed) {\n        renderPromises.registerSSRObservable(observable);\n        if (observable.getCurrentResult().loading) {\n            // TODO: This is a legacy API which could probably be cleaned up\n            renderPromises.addObservableQueryPromise(observable);\n        }\n    }\n}\n// this hook is not compatible with any rules of React, and there's no good way to rewrite it.\n// it should stay a separate hook that will not be optimized by the compiler\nfunction useResubscribeIfNecessary(\n/** this hook will mutate properties on `resultData` */\nresultData, \n/** this hook will mutate properties on `observable` */\nobservable, client, options, watchQueryOptions) {\n    var _a;\n    if (observable[lastWatchOptions] &&\n        !equal(observable[lastWatchOptions], watchQueryOptions)) {\n        // Though it might be tempting to postpone this reobserve call to the\n        // useEffect block, we need getCurrentResult to return an appropriate\n        // loading:true result synchronously (later within the same call to\n        // useQuery). Since we already have this.observable here (not true for\n        // the very first call to useQuery), we are not initiating any new\n        // subscriptions, though it does feel less than ideal that reobserve\n        // (potentially) kicks off a network request (for example, when the\n        // variables have changed), which is technically a side-effect.\n        observable.reobserve(getObsQueryOptions(observable, client, options, watchQueryOptions));\n        // Make sure getCurrentResult returns a fresh ApolloQueryResult<TData>,\n        // but save the current data as this.previousData, just like setResult\n        // usually does.\n        resultData.previousData =\n            ((_a = resultData.current) === null || _a === void 0 ? void 0 : _a.data) || resultData.previousData;\n        resultData.current = void 0;\n    }\n    observable[lastWatchOptions] = watchQueryOptions;\n}\n/*\n * A function to massage options before passing them to ObservableQuery.\n * This is two-step curried because we want to reuse the `make` function,\n * but the `observable` might differ between calls to `make`.\n */\nexport function createMakeWatchQueryOptions(client, query, _a, isSyncSSR) {\n    if (_a === void 0) { _a = {}; }\n    var skip = _a.skip, ssr = _a.ssr, onCompleted = _a.onCompleted, onError = _a.onError, defaultOptions = _a.defaultOptions, \n    // The above options are useQuery-specific, so this ...otherOptions spread\n    // makes otherOptions almost a WatchQueryOptions object, except for the\n    // query property that we add below.\n    otherOptions = __rest(_a, [\"skip\", \"ssr\", \"onCompleted\", \"onError\", \"defaultOptions\"]);\n    return function (observable) {\n        // This Object.assign is safe because otherOptions is a fresh ...rest object\n        // that did not exist until just now, so modifications are still allowed.\n        var watchQueryOptions = Object.assign(otherOptions, { query: query });\n        if (isSyncSSR &&\n            (watchQueryOptions.fetchPolicy === \"network-only\" ||\n                watchQueryOptions.fetchPolicy === \"cache-and-network\")) {\n            // this behavior was added to react-apollo without explanation in this PR\n            // https://github.com/apollographql/react-apollo/pull/1579\n            watchQueryOptions.fetchPolicy = \"cache-first\";\n        }\n        if (!watchQueryOptions.variables) {\n            watchQueryOptions.variables = {};\n        }\n        if (skip) {\n            // When skipping, we set watchQueryOptions.fetchPolicy initially to\n            // \"standby\", but we also need/want to preserve the initial non-standby\n            // fetchPolicy that would have been used if not skipping.\n            watchQueryOptions.initialFetchPolicy =\n                watchQueryOptions.initialFetchPolicy ||\n                    watchQueryOptions.fetchPolicy ||\n                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);\n            watchQueryOptions.fetchPolicy = \"standby\";\n        }\n        else if (!watchQueryOptions.fetchPolicy) {\n            watchQueryOptions.fetchPolicy =\n                (observable === null || observable === void 0 ? void 0 : observable.options.initialFetchPolicy) ||\n                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);\n        }\n        return watchQueryOptions;\n    };\n}\nexport function getObsQueryOptions(observable, client, queryHookOptions, watchQueryOptions) {\n    var toMerge = [];\n    var globalDefaults = client.defaultOptions.watchQuery;\n    if (globalDefaults)\n        toMerge.push(globalDefaults);\n    if (queryHookOptions.defaultOptions) {\n        toMerge.push(queryHookOptions.defaultOptions);\n    }\n    // We use compact rather than mergeOptions for this part of the merge,\n    // because we want watchQueryOptions.variables (if defined) to replace\n    // this.observable.options.variables whole. This replacement allows\n    // removing variables by removing them from the variables input to\n    // useQuery. If the variables were always merged together (rather than\n    // replaced), there would be no way to remove existing variables.\n    // However, the variables from options.defaultOptions and globalDefaults\n    // (if provided) should be merged, to ensure individual defaulted\n    // variables always have values, if not otherwise defined in\n    // observable.options or watchQueryOptions.\n    toMerge.push(compact(observable && observable.options, watchQueryOptions));\n    return toMerge.reduce(mergeOptions);\n}\nfunction setResult(nextResult, resultData, observable, client, partialRefetch, forceUpdate, callbacks) {\n    var previousResult = resultData.current;\n    if (previousResult && previousResult.data) {\n        resultData.previousData = previousResult.data;\n    }\n    if (!nextResult.error && isNonEmptyArray(nextResult.errors)) {\n        // Until a set naming convention for networkError and graphQLErrors is\n        // decided upon, we map errors (graphQLErrors) to the error options.\n        // TODO: Is it possible for both result.error and result.errors to be\n        // defined here?\n        nextResult.error = new ApolloError({ graphQLErrors: nextResult.errors });\n    }\n    resultData.current = toQueryResult(unsafeHandlePartialRefetch(nextResult, observable, partialRefetch), resultData.previousData, observable, client);\n    // Calling state.setResult always triggers an update, though some call sites\n    // perform additional equality checks before committing to an update.\n    forceUpdate();\n    handleErrorOrCompleted(nextResult, previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus, callbacks);\n}\nfunction handleErrorOrCompleted(result, previousNetworkStatus, callbacks) {\n    if (!result.loading) {\n        var error_1 = toApolloError(result);\n        // wait a tick in case we are in the middle of rendering a component\n        Promise.resolve()\n            .then(function () {\n            if (error_1) {\n                callbacks.onError(error_1);\n            }\n            else if (result.data &&\n                previousNetworkStatus !== result.networkStatus &&\n                result.networkStatus === NetworkStatus.ready) {\n                callbacks.onCompleted(result.data);\n            }\n        })\n            .catch(function (error) {\n            globalThis.__DEV__ !== false && invariant.warn(error);\n        });\n    }\n}\nfunction getCurrentResult(resultData, observable, callbacks, partialRefetch, client) {\n    // Using this.result as a cache ensures getCurrentResult continues returning\n    // the same (===) result object, unless state.setResult has been called, or\n    // we're doing server rendering and therefore override the result below.\n    if (!resultData.current) {\n        // WARNING: SIDE-EFFECTS IN THE RENDER FUNCTION\n        // this could call unsafeHandlePartialRefetch\n        setResult(observable.getCurrentResult(), resultData, observable, client, partialRefetch, function () { }, callbacks);\n    }\n    return resultData.current;\n}\nexport function getDefaultFetchPolicy(queryHookDefaultOptions, clientDefaultOptions) {\n    var _a;\n    return ((queryHookDefaultOptions === null || queryHookDefaultOptions === void 0 ? void 0 : queryHookDefaultOptions.fetchPolicy) ||\n        ((_a = clientDefaultOptions === null || clientDefaultOptions === void 0 ? void 0 : clientDefaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||\n        \"cache-first\");\n}\nexport function toApolloError(result) {\n    return isNonEmptyArray(result.errors) ?\n        new ApolloError({ graphQLErrors: result.errors })\n        : result.error;\n}\nexport function toQueryResult(result, previousData, observable, client) {\n    var data = result.data, partial = result.partial, resultWithoutPartial = __rest(result, [\"data\", \"partial\"]);\n    var queryResult = __assign(__assign({ data: data }, resultWithoutPartial), { client: client, observable: observable, variables: observable.variables, called: result !== ssrDisabledResult && result !== skipStandbyResult, previousData: previousData });\n    return queryResult;\n}\nfunction unsafeHandlePartialRefetch(result, observable, partialRefetch) {\n    // TODO: This code should be removed when the partialRefetch option is\n    // removed. I was unable to get this hook to behave reasonably in certain\n    // edge cases when this block was put in an effect.\n    if (result.partial &&\n        partialRefetch &&\n        !result.loading &&\n        (!result.data || Object.keys(result.data).length === 0) &&\n        observable.options.fetchPolicy !== \"cache-only\") {\n        observable.refetch();\n        return __assign(__assign({}, result), { loading: true, networkStatus: NetworkStatus.refetch });\n    }\n    return result;\n}\nvar ssrDisabledResult = maybeDeepFreeze({\n    loading: true,\n    data: void 0,\n    error: void 0,\n    networkStatus: NetworkStatus.loading,\n});\nvar skipStandbyResult = maybeDeepFreeze({\n    loading: false,\n    data: void 0,\n    error: void 0,\n    networkStatus: NetworkStatus.ready,\n});\nfunction bindObservableMethods(observable) {\n    return {\n        refetch: observable.refetch.bind(observable),\n        reobserve: observable.reobserve.bind(observable),\n        fetchMore: observable.fetchMore.bind(observable),\n        updateQuery: observable.updateQuery.bind(observable),\n        startPolling: observable.startPolling.bind(observable),\n        stopPolling: observable.stopPolling.bind(observable),\n        subscribeToMore: observable.subscribeToMore.bind(observable),\n    };\n}\n//# sourceMappingURL=useQuery.js.map","// A version of Array.isArray that works better with readonly arrays.\nexport var isArray = Array.isArray;\nexport function isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n//# sourceMappingURL=arrays.js.map","import { isNonNullObject } from \"./objects.js\";\nfunction deepFreeze(value) {\n    var workSet = new Set([value]);\n    workSet.forEach(function (obj) {\n        if (isNonNullObject(obj) && shallowFreeze(obj) === obj) {\n            Object.getOwnPropertyNames(obj).forEach(function (name) {\n                if (isNonNullObject(obj[name]))\n                    workSet.add(obj[name]);\n            });\n        }\n    });\n    return value;\n}\nfunction shallowFreeze(obj) {\n    if (globalThis.__DEV__ !== false && !Object.isFrozen(obj)) {\n        try {\n            Object.freeze(obj);\n        }\n        catch (e) {\n            // Some types like Uint8Array and Node.js's Buffer cannot be frozen, but\n            // they all throw a TypeError when you try, so we re-throw any exceptions\n            // that are not TypeErrors, since that would be unexpected.\n            if (e instanceof TypeError)\n                return null;\n            throw e;\n        }\n    }\n    return obj;\n}\nexport function maybeDeepFreeze(obj) {\n    if (globalThis.__DEV__ !== false) {\n        deepFreeze(obj);\n    }\n    return obj;\n}\n//# sourceMappingURL=maybeDeepFreeze.js.map"],"names":["NetworkStatus","isNetworkRequestInFlight","networkStatus","didWarnUncachedGetSnapshot","useSyncExternalStore","realHook","subscribe","getSnapshot","getServerSnapshot","value","globalThis","__DEV__","globals","kG","error","_a","rehackt","useState","inst","forceUpdate","canUse","JC","useLayoutEffect","Object","assign","checkIfSnapshotChanged","useEffect","_b","wrapperSymbol","Symbol","for","useQuery_hasOwnProperty","prototype","hasOwnProperty","noop","lastWatchOptions","useQuery","query","options","useHook","queryManager","wrappers","wrapper","create","wrapHook","_useQuery","clientOrObsQuery","useApolloClient","x","client","useQueryInternals","result","obsQueryFields","useMemo","tslib_es6","__assign","callbacks","callbackRef","resultOverride","previousData","currentResultOverride","renderPromises","useContext","ApolloContext","K","isSyncSSR","disableNetworkFetches","ssrAllowed","ssr","skip","partialRefetch","makeWatchQueryOptions","createMakeWatchQueryOptions","useInternalState","createInternalState","previous","parser","Vp","n_","Query","observable","getSSRObservable","watchQuery","getObsQueryOptions","resultData","current","data","internalState","updateInternalState","onQueryExecuted","watchQueryOptions","undefined","newInternalState","lib","D","reobserve","refetch","bind","fetchMore","updateQuery","startPolling","stopPolling","subscribeToMore","registerSSRObservable","getCurrentResult","loading","addObservableQueryPromise","onCompleted","onError","useRef","ssrDisabledResult","fetchPolicy","skipStandbyResult","toQueryResult","useCallback","handleStoreChange","onNext","previousResult","setResult","subscription","unsubscribe","resubscribeAfterError","call","Ie","setTimeout","defaultOptions","otherOptions","__rest","variables","initialFetchPolicy","getDefaultFetchPolicy","queryHookOptions","toMerge","globalDefaults","push","compact","o","reduce","mergeOptions","J","nextResult","arrays","O","errors","cA","graphQLErrors","partial","keys","length","handleErrorOrCompleted","previousNetworkStatus","error_1","Promise","resolve","then","ready","catch","warn","queryHookDefaultOptions","clientDefaultOptions","resultWithoutPartial","called","maybeDeepFreeze","isArray","Array","isNonEmptyArray","obj","workSet","Set","forEach","_objects_js__WEBPACK_IMPORTED_MODULE_0__","s","shallowFreeze","isFrozen","freeze","e","TypeError","getOwnPropertyNames","name","add"],"sourceRoot":""}