{"version":3,"file":"static/chunks/5760-dab4d7516cfdfa1d.js","mappings":"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","sources":["webpack://_N_E/../../node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js","webpack://_N_E/../../node_modules/@tanstack/query-core/build/modern/infiniteQueryObserver.js","webpack://_N_E/../../node_modules/@tanstack/query-core/build/modern/hydration.js","webpack://_N_E/../../src/HydrationBoundary.tsx","webpack://_N_E/../../src/useInfiniteQuery.ts","webpack://_N_E/../../src/useIsFetching.ts","webpack://_N_E/../../src/useMutationState.ts","webpack://_N_E/../../node_modules/@tanstack/query-core/build/modern/queriesObserver.js","webpack://_N_E/../../src/useQueries.ts","webpack://_N_E/../../src/useSuspenseInfiniteQuery.ts","webpack://_N_E/../../src/useSuspenseQueries.ts","webpack://_N_E/../../src/useSuspenseQuery.ts"],"sourcesContent":["// src/infiniteQueryBehavior.ts\nimport { addToEnd, addToStart, ensureQueryFn } from \"./utils.js\";\nfunction infiniteQueryBehavior(pages) {\n return {\n onFetch: (context, query) => {\n const options = context.options;\n const direction = context.fetchOptions?.meta?.fetchMore?.direction;\n const oldPages = context.state.data?.pages || [];\n const oldPageParams = context.state.data?.pageParams || [];\n let result = { pages: [], pageParams: [] };\n let currentPage = 0;\n const fetchFn = async () => {\n let cancelled = false;\n const addSignalProperty = (object) => {\n Object.defineProperty(object, \"signal\", {\n enumerable: true,\n get: () => {\n if (context.signal.aborted) {\n cancelled = true;\n } else {\n context.signal.addEventListener(\"abort\", () => {\n cancelled = true;\n });\n }\n return context.signal;\n }\n });\n };\n const queryFn = ensureQueryFn(context.options, context.fetchOptions);\n const fetchPage = async (data, param, previous) => {\n if (cancelled) {\n return Promise.reject();\n }\n if (param == null && data.pages.length) {\n return Promise.resolve(data);\n }\n const queryFnContext = {\n client: context.client,\n queryKey: context.queryKey,\n pageParam: param,\n direction: previous ? \"backward\" : \"forward\",\n meta: context.options.meta\n };\n addSignalProperty(queryFnContext);\n const page = await queryFn(\n queryFnContext\n );\n const { maxPages } = context.options;\n const addTo = previous ? addToStart : addToEnd;\n return {\n pages: addTo(data.pages, page, maxPages),\n pageParams: addTo(data.pageParams, param, maxPages)\n };\n };\n if (direction && oldPages.length) {\n const previous = direction === \"backward\";\n const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;\n const oldData = {\n pages: oldPages,\n pageParams: oldPageParams\n };\n const param = pageParamFn(options, oldData);\n result = await fetchPage(oldData, param, previous);\n } else {\n const remainingPages = pages ?? oldPages.length;\n do {\n const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result);\n if (currentPage > 0 && param == null) {\n break;\n }\n result = await fetchPage(result, param);\n currentPage++;\n } while (currentPage < remainingPages);\n }\n return result;\n };\n if (context.options.persister) {\n context.fetchFn = () => {\n return context.options.persister?.(\n fetchFn,\n {\n client: context.client,\n queryKey: context.queryKey,\n meta: context.options.meta,\n signal: context.signal\n },\n query\n );\n };\n } else {\n context.fetchFn = fetchFn;\n }\n }\n };\n}\nfunction getNextPageParam(options, { pages, pageParams }) {\n const lastIndex = pages.length - 1;\n return pages.length > 0 ? options.getNextPageParam(\n pages[lastIndex],\n pages,\n pageParams[lastIndex],\n pageParams\n ) : void 0;\n}\nfunction getPreviousPageParam(options, { pages, pageParams }) {\n return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0;\n}\nfunction hasNextPage(options, data) {\n if (!data)\n return false;\n return getNextPageParam(options, data) != null;\n}\nfunction hasPreviousPage(options, data) {\n if (!data || !options.getPreviousPageParam)\n return false;\n return getPreviousPageParam(options, data) != null;\n}\nexport {\n hasNextPage,\n hasPreviousPage,\n infiniteQueryBehavior\n};\n//# sourceMappingURL=infiniteQueryBehavior.js.map","// src/infiniteQueryObserver.ts\nimport { QueryObserver } from \"./queryObserver.js\";\nimport {\n hasNextPage,\n hasPreviousPage,\n infiniteQueryBehavior\n} from \"./infiniteQueryBehavior.js\";\nvar InfiniteQueryObserver = class extends QueryObserver {\n constructor(client, options) {\n super(client, options);\n }\n bindMethods() {\n super.bindMethods();\n this.fetchNextPage = this.fetchNextPage.bind(this);\n this.fetchPreviousPage = this.fetchPreviousPage.bind(this);\n }\n setOptions(options, notifyOptions) {\n super.setOptions(\n {\n ...options,\n behavior: infiniteQueryBehavior()\n },\n notifyOptions\n );\n }\n getOptimisticResult(options) {\n options.behavior = infiniteQueryBehavior();\n return super.getOptimisticResult(options);\n }\n fetchNextPage(options) {\n return this.fetch({\n ...options,\n meta: {\n fetchMore: { direction: \"forward\" }\n }\n });\n }\n fetchPreviousPage(options) {\n return this.fetch({\n ...options,\n meta: {\n fetchMore: { direction: \"backward\" }\n }\n });\n }\n createResult(query, options) {\n const { state } = query;\n const parentResult = super.createResult(query, options);\n const { isFetching, isRefetching, isError, isRefetchError } = parentResult;\n const fetchDirection = state.fetchMeta?.fetchMore?.direction;\n const isFetchNextPageError = isError && fetchDirection === \"forward\";\n const isFetchingNextPage = isFetching && fetchDirection === \"forward\";\n const isFetchPreviousPageError = isError && fetchDirection === \"backward\";\n const isFetchingPreviousPage = isFetching && fetchDirection === \"backward\";\n const result = {\n ...parentResult,\n fetchNextPage: this.fetchNextPage,\n fetchPreviousPage: this.fetchPreviousPage,\n hasNextPage: hasNextPage(options, state.data),\n hasPreviousPage: hasPreviousPage(options, state.data),\n isFetchNextPageError,\n isFetchingNextPage,\n isFetchPreviousPageError,\n isFetchingPreviousPage,\n isRefetchError: isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,\n isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage\n };\n return result;\n }\n};\nexport {\n InfiniteQueryObserver\n};\n//# sourceMappingURL=infiniteQueryObserver.js.map","// src/hydration.ts\nfunction defaultTransformerFn(data) {\n return data;\n}\nfunction dehydrateMutation(mutation) {\n return {\n mutationKey: mutation.options.mutationKey,\n state: mutation.state,\n ...mutation.options.scope && { scope: mutation.options.scope },\n ...mutation.meta && { meta: mutation.meta }\n };\n}\nfunction dehydrateQuery(query, serializeData, shouldRedactErrors) {\n return {\n state: {\n ...query.state,\n ...query.state.data !== void 0 && {\n data: serializeData(query.state.data)\n }\n },\n queryKey: query.queryKey,\n queryHash: query.queryHash,\n ...query.state.status === \"pending\" && {\n promise: query.promise?.then(serializeData).catch((error) => {\n if (!shouldRedactErrors(error)) {\n return Promise.reject(error);\n }\n if (process.env.NODE_ENV !== \"production\") {\n console.error(\n `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`\n );\n }\n return Promise.reject(new Error(\"redacted\"));\n })\n },\n ...query.meta && { meta: query.meta }\n };\n}\nfunction defaultShouldDehydrateMutation(mutation) {\n return mutation.state.isPaused;\n}\nfunction defaultShouldDehydrateQuery(query) {\n return query.state.status === \"success\";\n}\nfunction defaultshouldRedactErrors(_) {\n return true;\n}\nfunction dehydrate(client, options = {}) {\n const filterMutation = options.shouldDehydrateMutation ?? client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;\n const mutations = client.getMutationCache().getAll().flatMap(\n (mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []\n );\n const filterQuery = options.shouldDehydrateQuery ?? client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ?? defaultShouldDehydrateQuery;\n const shouldRedactErrors = options.shouldRedactErrors ?? client.getDefaultOptions().dehydrate?.shouldRedactErrors ?? defaultshouldRedactErrors;\n const serializeData = options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData ?? defaultTransformerFn;\n const queries = client.getQueryCache().getAll().flatMap(\n (query) => filterQuery(query) ? [dehydrateQuery(query, serializeData, shouldRedactErrors)] : []\n );\n return { mutations, queries };\n}\nfunction hydrate(client, dehydratedState, options) {\n if (typeof dehydratedState !== \"object\" || dehydratedState === null) {\n return;\n }\n const mutationCache = client.getMutationCache();\n const queryCache = client.getQueryCache();\n const deserializeData = options?.defaultOptions?.deserializeData ?? client.getDefaultOptions().hydrate?.deserializeData ?? defaultTransformerFn;\n const mutations = dehydratedState.mutations || [];\n const queries = dehydratedState.queries || [];\n mutations.forEach(({ state, ...mutationOptions }) => {\n mutationCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.mutations,\n ...options?.defaultOptions?.mutations,\n ...mutationOptions\n },\n state\n );\n });\n queries.forEach(({ queryKey, state, queryHash, meta, promise }) => {\n let query = queryCache.get(queryHash);\n const data = state.data === void 0 ? state.data : deserializeData(state.data);\n if (query) {\n if (query.state.dataUpdatedAt < state.dataUpdatedAt) {\n const { fetchStatus: _ignored, ...serializedState } = state;\n query.setState({\n ...serializedState,\n data\n });\n }\n } else {\n query = queryCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.queries,\n ...options?.defaultOptions?.queries,\n queryKey,\n queryHash,\n meta\n },\n // Reset fetch status to idle to avoid\n // query being stuck in fetching state upon hydration\n {\n ...state,\n data,\n fetchStatus: \"idle\"\n }\n );\n }\n if (promise) {\n const initialPromise = Promise.resolve(promise).then(deserializeData);\n void query.fetch(void 0, { initialPromise });\n }\n });\n}\nexport {\n defaultShouldDehydrateMutation,\n defaultShouldDehydrateQuery,\n defaultshouldRedactErrors,\n dehydrate,\n hydrate\n};\n//# sourceMappingURL=hydration.js.map","/* eslint-disable react-compiler/react-compiler */\n\n'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state?: unknown\n options?: OmitKeyof & {\n defaultOptions?: OmitKeyof<\n Exclude,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nconst hasProperty = (\n obj: unknown,\n key: TKey,\n): obj is { [k in TKey]: unknown } => {\n return typeof obj === 'object' && obj !== null && key in obj\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n const [hydrationQueue, setHydrationQueue] = React.useState<\n DehydratedState['queries'] | undefined\n >()\n\n const optionsRef = React.useRef(options)\n optionsRef.current = options\n\n // This useMemo is for performance reasons only, everything inside it _must_\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = (state as DehydratedState).queries || []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt || // RSC special serialized then-able chunks\n (hasProperty(dehydratedQuery.promise, 'status') &&\n hasProperty(existingQuery.promise, 'status') &&\n dehydratedQuery.promise.status !== existingQuery.promise.status)\n\n const queryAlreadyQueued = hydrationQueue?.find(\n (query) => query.queryHash === dehydratedQuery.queryHash,\n )\n\n if (\n hydrationIsNewer &&\n (!queryAlreadyQueued ||\n dehydratedQuery.state.dataUpdatedAt >\n queryAlreadyQueued.state.dataUpdatedAt)\n ) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n setHydrationQueue((prev) =>\n prev ? [...prev, ...existingQueries] : existingQueries,\n )\n }\n }\n }, [client, hydrationQueue, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n setHydrationQueue(undefined)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n","'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryFnData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n","'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n","/* eslint-disable react-compiler/react-compiler */\n\n'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationStateOptions = {\n filters?: MutationFilters\n select?: (mutation: Mutation) => TResult\n}\n\nfunction getResult(\n mutationCache: MutationCache,\n options: MutationStateOptions,\n): Array {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select ? options.select(mutation) : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState(\n options: MutationStateOptions = {},\n queryClient?: QueryClient,\n): Array {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef>(null)\n if (!result.current) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n","// src/queriesObserver.ts\nimport { notifyManager } from \"./notifyManager.js\";\nimport { QueryObserver } from \"./queryObserver.js\";\nimport { Subscribable } from \"./subscribable.js\";\nimport { replaceEqualDeep } from \"./utils.js\";\nfunction difference(array1, array2) {\n return array1.filter((x) => !array2.includes(x));\n}\nfunction replaceAt(array, index, value) {\n const copy = array.slice(0);\n copy[index] = value;\n return copy;\n}\nvar QueriesObserver = class extends Subscribable {\n #client;\n #result;\n #queries;\n #options;\n #observers;\n #combinedResult;\n #lastCombine;\n #lastResult;\n #observerMatches = [];\n constructor(client, queries, options) {\n super();\n this.#client = client;\n this.#options = options;\n this.#queries = [];\n this.#observers = [];\n this.#result = [];\n this.setQueries(queries);\n }\n onSubscribe() {\n if (this.listeners.size === 1) {\n this.#observers.forEach((observer) => {\n observer.subscribe((result) => {\n this.#onUpdate(observer, result);\n });\n });\n }\n }\n onUnsubscribe() {\n if (!this.listeners.size) {\n this.destroy();\n }\n }\n destroy() {\n this.listeners = /* @__PURE__ */ new Set();\n this.#observers.forEach((observer) => {\n observer.destroy();\n });\n }\n setQueries(queries, options, notifyOptions) {\n this.#queries = queries;\n this.#options = options;\n if (process.env.NODE_ENV !== \"production\") {\n const queryHashes = queries.map(\n (query) => this.#client.defaultQueryOptions(query).queryHash\n );\n if (new Set(queryHashes).size !== queryHashes.length) {\n console.warn(\n \"[QueriesObserver]: Duplicate Queries found. This might result in unexpected behavior.\"\n );\n }\n }\n notifyManager.batch(() => {\n const prevObservers = this.#observers;\n const newObserverMatches = this.#findMatchingObservers(this.#queries);\n this.#observerMatches = newObserverMatches;\n newObserverMatches.forEach(\n (match) => match.observer.setOptions(match.defaultedQueryOptions, notifyOptions)\n );\n const newObservers = newObserverMatches.map((match) => match.observer);\n const newResult = newObservers.map(\n (observer) => observer.getCurrentResult()\n );\n const hasIndexChange = newObservers.some(\n (observer, index) => observer !== prevObservers[index]\n );\n if (prevObservers.length === newObservers.length && !hasIndexChange) {\n return;\n }\n this.#observers = newObservers;\n this.#result = newResult;\n if (!this.hasListeners()) {\n return;\n }\n difference(prevObservers, newObservers).forEach((observer) => {\n observer.destroy();\n });\n difference(newObservers, prevObservers).forEach((observer) => {\n observer.subscribe((result) => {\n this.#onUpdate(observer, result);\n });\n });\n this.#notify();\n });\n }\n getCurrentResult() {\n return this.#result;\n }\n getQueries() {\n return this.#observers.map((observer) => observer.getCurrentQuery());\n }\n getObservers() {\n return this.#observers;\n }\n getOptimisticResult(queries, combine) {\n const matches = this.#findMatchingObservers(queries);\n const result = matches.map(\n (match) => match.observer.getOptimisticResult(match.defaultedQueryOptions)\n );\n return [\n result,\n (r) => {\n return this.#combineResult(r ?? result, combine);\n },\n () => {\n return this.#trackResult(result, matches);\n }\n ];\n }\n #trackResult(result, matches) {\n return matches.map((match, index) => {\n const observerResult = result[index];\n return !match.defaultedQueryOptions.notifyOnChangeProps ? match.observer.trackResult(observerResult, (accessedProp) => {\n matches.forEach((m) => {\n m.observer.trackProp(accessedProp);\n });\n }) : observerResult;\n });\n }\n #combineResult(input, combine) {\n if (combine) {\n if (!this.#combinedResult || this.#result !== this.#lastResult || combine !== this.#lastCombine) {\n this.#lastCombine = combine;\n this.#lastResult = this.#result;\n this.#combinedResult = replaceEqualDeep(\n this.#combinedResult,\n combine(input)\n );\n }\n return this.#combinedResult;\n }\n return input;\n }\n #findMatchingObservers(queries) {\n const prevObserversMap = new Map(\n this.#observers.map((observer) => [observer.options.queryHash, observer])\n );\n const observers = [];\n queries.forEach((options) => {\n const defaultedOptions = this.#client.defaultQueryOptions(options);\n const match = prevObserversMap.get(defaultedOptions.queryHash);\n if (match) {\n observers.push({\n defaultedQueryOptions: defaultedOptions,\n observer: match\n });\n } else {\n observers.push({\n defaultedQueryOptions: defaultedOptions,\n observer: new QueryObserver(this.#client, defaultedOptions)\n });\n }\n });\n return observers;\n }\n #onUpdate(observer, result) {\n const index = this.#observers.indexOf(observer);\n if (index !== -1) {\n this.#result = replaceAt(this.#result, index, result);\n this.#notify();\n }\n }\n #notify() {\n if (this.hasListeners()) {\n const previousResult = this.#combinedResult;\n const newTracked = this.#trackResult(this.#result, this.#observerMatches);\n const newResult = this.#combineResult(newTracked, this.#options?.combine);\n if (previousResult !== newResult) {\n notifyManager.batch(() => {\n this.listeners.forEach((listener) => {\n listener(this.#result);\n });\n });\n }\n }\n }\n};\nexport {\n QueriesObserver\n};\n//# sourceMappingURL=queriesObserver.js.map","'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './isRestoring'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n willFetch,\n} from './suspense'\nimport { noop } from './utils'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions,\n 'placeholderData' | 'subscribed'\n> & {\n placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult\n : TInitialData extends TData\n ? DefinedUseQueryResult\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult\n : UseQueryResult\n : UseQueryResult\n : UseQueryResult\n\ntype GetUseQueryResult =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/**\n * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n */\nexport type QueriesOptions<\n T extends Array,\n TResults extends Array = [],\n TDepth extends ReadonlyArray = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries],\n [...TDepth, 1]\n >\n : ReadonlyArray extends T\n ? T\n : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array\n\n/**\n * QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array,\n TResults extends Array = [],\n TDepth extends ReadonlyArray = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult }\n\nexport function useQueries<\n T extends Array,\n TCombinedResult = QueriesResults,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n | readonly [...QueriesOptions]\n | readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries }]\n combine?: (result: QueriesResults) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : 'optimistic'\n\n return defaultedOptions\n }),\n [queries, client, isRestoring],\n )\n\n defaultedQueries.forEach((query) => {\n ensureSuspenseTimers(query)\n ensurePreventErrorBoundaryRetry(query, errorResetBoundary)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver(\n client,\n defaultedQueries,\n options as QueriesObserverOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions).combine,\n )\n\n const shouldSubscribe = !isRestoring && options.subscribed !== false\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n // Do not notify on updates because of changes in the options because\n // these changes should already be reflected in the optimistic result.\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions,\n {\n listeners: false,\n },\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts) {\n const queryObserver = new QueryObserver(client, opts)\n if (shouldSuspend(opts, result)) {\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n } else if (willFetch(result, isRestoring)) {\n void fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n","'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryFnData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult\n}\n","'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n throwOnError?: ThrowOnError\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n throwOnError?: ThrowOnError\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/**\n * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n */\nexport type SuspenseQueriesOptions<\n T extends Array,\n TResults extends Array = [],\n TDepth extends ReadonlyArray = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions],\n [...TDepth, 1]\n >\n : Array extends T\n ? T\n : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions\n >\n : // Fallback\n Array\n\n/**\n * SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array,\n TResults extends Array = [],\n TDepth extends ReadonlyArray = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult }\n\nexport function useSuspenseQueries<\n T extends Array,\n TCombinedResult = SuspenseQueriesResults,\n>(\n options: {\n queries:\n | readonly [...SuspenseQueriesOptions]\n | readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions }]\n combine?: (result: SuspenseQueriesResults) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array,\n TCombinedResult = SuspenseQueriesResults,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions]\n combine?: (result: SuspenseQueriesResults) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n","'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult\n}\n"],"names":["infiniteQueryBehavior","pages","onFetch","context","query","options","direction","fetchOptions","meta","fetchMore","oldPages","state","data","oldPageParams","pageParams","result","currentPage","fetchFn","cancelled","addSignalProperty","Object","defineProperty","object","enumerable","get","signal","aborted","addEventListener","queryFn","_utils_js__WEBPACK_IMPORTED_MODULE_0__","cG","fetchPage","param","previous","Promise","reject","length","resolve","queryFnContext","client","queryKey","pageParam","page","maxPages","addTo","Ht","VX","oldData","pageParamFn","getPreviousPageParam","getNextPageParam","remainingPages","initialPageParam","persister","lastIndex","hasNextPage","hasPreviousPage","InfiniteQueryObserver","_queryObserver_js__WEBPACK_IMPORTED_MODULE_0__","z","constructor","bindMethods","fetchNextPage","bind","fetchPreviousPage","setOptions","notifyOptions","behavior","_infiniteQueryBehavior_js__WEBPACK_IMPORTED_MODULE_1__","Gm","getOptimisticResult","fetch","createResult","parentResult","isFetching","isRefetching","isError","isRefetchError","fetchDirection","fetchMeta","isFetchNextPageError","isFetchingNextPage","isFetchPreviousPageError","isFetchingPreviousPage","Qy","ZF","defaultTransformerFn","hydrate","dehydratedState","mutationCache","getMutationCache","queryCache","getQueryCache","deserializeData","defaultOptions","getDefaultOptions","mutations","queries","forEach","mutationOptions","build","queryHash","promise","dataUpdatedAt","fetchStatus","_ignored","serializedState","setState","initialPromise","then","hasProperty","obj","key","HydrationBoundary","children","queryClient","useQueryClient","hydrationQueue","setHydrationQueue","React","optionsRef","current","newQueries","existingQueries","dehydratedQuery","existingQuery","hydrationIsNewer","status","queryAlreadyQueued","find","push","prev","useInfiniteQuery","useBaseQuery","useIsFetching","filters","subscribe","notifyManager","batchCalls","onStoreChange","useIsMutating","useMutationState","getResult","findAll","map","select","mutation","nextResult","replaceEqualDeep","schedule","difference","array1","array2","filter","includes","x","QueriesObserver","subscribable","l","observers","combinedResult","lastCombine","lastResult","observerMatches","setQueries","onSubscribe","listeners","size","observer","onUpdate","onUnsubscribe","destroy","Set","V","batch","prevObservers","newObserverMatches","findMatchingObservers","match","defaultedQueryOptions","newObservers","newResult","getCurrentResult","hasIndexChange","some","index","hasListeners","notify","getQueries","getCurrentQuery","getObservers","combine","matches","combineResult","r","trackResult","observerResult","notifyOnChangeProps","m","trackProp","accessedProp","input","utils","Q$","prevObserversMap","Map","defaultedOptions","defaultQueryOptions","modern_queryObserver","indexOf","replaceAt","array","value","copy","slice","previousResult","newTracked","listener","useQueries","isRestoring","useIsRestoring","errorResetBoundary","useQueryErrorResetBoundary","defaultedQueries","opts","_optimisticResults","ensureSuspenseTimers","ensurePreventErrorBoundaryRetry","useClearResetErrorBoundary","optimisticResult","getCombinedResult","shouldSubscribe","subscribed","noop","suspensePromises","shouldAtLeastOneSuspend","shouldSuspend","flatMap","queryObserver","QueryObserver","fetchOptimistic","willFetch","all","firstSingleResultWhichShouldThrow","getHasError","throwOnError","suspense","error","useSuspenseInfiniteQuery","enabled","defaultThrowOnError","useSuspenseQueries","placeholderData","useSuspenseQuery"],"sourceRoot":""}