{"version":3,"file":"static/chunks/8420-7ede6da83132a94b.js","mappings":"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","sources":["webpack://_N_E/../../node_modules/@tanstack/query-core/build/modern/hydration.js","webpack://_N_E/../../src/HydrationBoundary.tsx","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/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) {\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 (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 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 serializeData = options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData ?? defaultTransformerFn;\n  const queries = client.getQueryCache().getAll().flatMap(\n    (query) => filterQuery(query) ? [dehydrateQuery(query, serializeData)] : []\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  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<HydrateOptions, 'defaultOptions'> & {\n    defaultOptions?: OmitKeyof<\n      Exclude<HydrateOptions['defaultOptions'], undefined>,\n      'mutations'\n    >\n  }\n  children?: React.ReactNode\n  queryClient?: QueryClient\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\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 * 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<TResult = MutationState> = {\n  filters?: MutationFilters\n  select?: (mutation: Mutation) => TResult\n}\n\nfunction getResult<TResult = MutationState>(\n  mutationCache: MutationCache,\n  options: MutationStateOptions<TResult>,\n): Array<TResult> {\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<TResult = MutationState>(\n  options: MutationStateOptions<TResult> = {},\n  queryClient?: QueryClient,\n): Array<TResult> {\n  const mutationCache = useQueryClient(queryClient).getMutationCache()\n  const optionsRef = React.useRef(options)\n  const result = React.useRef<Array<TResult>>(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  #observers;\n  #combinedResult;\n  #lastCombine;\n  #lastResult;\n  constructor(client, queries, _options) {\n    super();\n    this.#client = client;\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    notifyManager.batch(() => {\n      const prevObservers = this.#observers;\n      const newObserverMatches = this.#findMatchingObservers(this.#queries);\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 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    ];\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 prevObservers = this.#observers;\n    const prevObserversMap = new Map(\n      prevObservers.map((observer) => [observer.options.queryHash, observer])\n    );\n    const defaultedQueryOptions = queries.map(\n      (options) => this.#client.defaultQueryOptions(options)\n    );\n    const matchingObservers = defaultedQueryOptions.flatMap((defaultedOptions) => {\n      const match = prevObserversMap.get(defaultedOptions.queryHash);\n      if (match != null) {\n        return [{ defaultedQueryOptions: defaultedOptions, observer: match }];\n      }\n      return [];\n    });\n    const matchedQueryHashes = new Set(\n      matchingObservers.map((match) => match.defaultedQueryOptions.queryHash)\n    );\n    const unmatchedQueries = defaultedQueryOptions.filter(\n      (defaultedOptions) => !matchedQueryHashes.has(defaultedOptions.queryHash)\n    );\n    const getObserver = (options) => {\n      const defaultedOptions = this.#client.defaultQueryOptions(options);\n      const currentObserver = this.#observers.find(\n        (o) => o.options.queryHash === defaultedOptions.queryHash\n      );\n      return currentObserver ?? new QueryObserver(this.#client, defaultedOptions);\n    };\n    const newOrReusedObservers = unmatchedQueries.map((options) => {\n      return {\n        defaultedQueryOptions: options,\n        observer: getObserver(options)\n      };\n    });\n    const sortMatchesByOrderOfQueries = (a, b) => defaultedQueryOptions.indexOf(a.defaultedQueryOptions) - defaultedQueryOptions.indexOf(b.defaultedQueryOptions);\n    return matchingObservers.concat(newOrReusedObservers).sort(sortMatchesByOrderOfQueries);\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    notifyManager.batch(() => {\n      this.listeners.forEach((listener) => {\n        listener(this.#result);\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 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<TQueryFnData, TError, TData, TQueryKey>,\n  'placeholderData'\n> & {\n  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>\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<T> =\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<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseQueryOptionsForUseQueries<unknown, TError, TData>\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<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseQueryOptionsForUseQueries<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseQueryOptionsForUseQueries<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\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, TData, TError = unknown> = T extends {\n  initialData?: infer TInitialData\n}\n  ? unknown extends TInitialData\n    ? UseQueryResult<TData, TError>\n    : TInitialData extends TData\n      ? DefinedUseQueryResult<TData, TError>\n      : TInitialData extends () => infer TInitialDataResult\n        ? unknown extends TInitialDataResult\n          ? UseQueryResult<TData, TError>\n          : TInitialDataResult extends TData\n            ? DefinedUseQueryResult<TData, TError>\n            : UseQueryResult<TData, TError>\n        : UseQueryResult<TData, TError>\n  : UseQueryResult<TData, TError>\n\ntype GetUseQueryResult<T> =\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<T, TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\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<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseQueryOptionsForUseQueries>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesOptions<\n            [...Tails],\n            [...TResults, GetUseQueryOptionsForUseQueries<Head>],\n            [...TDepth, 1]\n          >\n        : ReadonlyArray<unknown> 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<UseQueryOptionsForUseQueries>\n\n/**\n * QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesResults<\n            [...Tails],\n            [...TResults, GetUseQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : T extends Array<\n              UseQueryOptionsForUseQueries<\n                infer TQueryFnData,\n                infer TError,\n                infer TData,\n                any\n              >\n            >\n          ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results\n            Array<\n              UseQueryResult<\n                unknown extends TData ? TQueryFnData : TData,\n                unknown extends TError ? DefaultError : TError\n              >\n            >\n          : // Fallback\n            Array<UseQueryResult>\n\nexport function useQueries<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n>(\n  {\n    queries,\n    ...options\n  }: {\n    queries: readonly [...QueriesOptions<T>]\n    combine?: (result: QueriesResults<T>) => TCombinedResult\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<TCombinedResult>(\n        client,\n        defaultedQueries,\n        options as QueriesObserverOptions<TCombinedResult>,\n      ),\n  )\n\n  const [optimisticResult, getCombinedResult, trackResult] =\n    observer.getOptimisticResult(\n      defaultedQueries,\n      (options as QueriesObserverOptions<TCombinedResult>).combine,\n    )\n\n  React.useSyncExternalStore(\n    React.useCallback(\n      (onStoreChange) =>\n        isRestoring\n          ? () => undefined\n          : observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n      [observer, isRestoring],\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<TCombinedResult>,\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        })\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<TQueryFnData>,\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<TData, TError> {\n  if (process.env.NODE_ENV !== 'production') {\n    if (options.queryFn === 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<TData, TError>\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<T> =\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<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryOptions<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryOptions<unknown, TError, TData>\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<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryOptions<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryOptions<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryOptions<\n                    TQueryFnData,\n                    TError,\n                    TData,\n                    TQueryKey\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\n                    }\n                  ? UseSuspenseQueryOptions<\n                      TQueryFnData,\n                      TError,\n                      TQueryFnData,\n                      TQueryKey\n                    >\n                  : // Fallback\n                    UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult<T> =\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<TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? UseSuspenseQueryResult<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? UseSuspenseQueryResult<TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? UseSuspenseQueryResult<TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? UseSuspenseQueryResult<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? UseSuspenseQueryResult<TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForUseQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? UseSuspenseQueryResult<\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : T extends {\n                      queryFn?:\n                        | QueryFunction<infer TQueryFnData, any>\n                        | SkipTokenForUseQueries\n                      throwOnError?: ThrowOnError<any, infer TError, any, any>\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<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryOptions>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryOptions<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesOptions<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryOptions<Head>],\n            [...TDepth, 1]\n          >\n        : Array<unknown> 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<TQueryFnData, TError, TData, TQueryKey>\n              >\n            : // Fallback\n              Array<UseSuspenseQueryOptions>\n\n/**\n * SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<UseSuspenseQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetUseSuspenseQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? SuspenseQueriesResults<\n            [...Tails],\n            [...TResults, GetUseSuspenseQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : T extends Array<\n              UseSuspenseQueryOptions<\n                infer TQueryFnData,\n                infer TError,\n                infer TData,\n                any\n              >\n            >\n          ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results\n            Array<\n              UseSuspenseQueryResult<\n                unknown extends TData ? TQueryFnData : TData,\n                unknown extends TError ? DefaultError : TError\n              >\n            >\n          : // Fallback\n            Array<UseSuspenseQueryResult>\n\nexport function useSuspenseQueries<\n  T extends Array<any>,\n  TCombinedResult = SuspenseQueriesResults<T>,\n>(\n  options: {\n    queries: readonly [...SuspenseQueriesOptions<T>]\n    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult\n  },\n  queryClient?: QueryClient,\n): TCombinedResult {\n  return useQueries(\n    {\n      ...options,\n      queries: options.queries.map((query) => {\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    } as any,\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<TQueryFnData, TError, TData, TQueryKey>,\n  queryClient?: QueryClient,\n): UseSuspenseQueryResult<TData, TError> {\n  if (process.env.NODE_ENV !== 'production') {\n    if (options.queryFn === 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<TData, TError>\n}\n"],"names":["defaultTransformerFn","data","hydrate","client","dehydratedState","options","mutationCache","getMutationCache","queryCache","getQueryCache","deserializeData","defaultOptions","getDefaultOptions","mutations","queries","forEach","state","mutationOptions","build","queryKey","queryHash","meta","promise","query","get","dataUpdatedAt","fetchStatus","_ignored","serializedState","setState","initialPromise","Promise","resolve","then","fetch","HydrationBoundary","children","queryClient","param","useQueryClient","hydrationQueue","setHydrationQueue","React","optionsRef","current","newQueries","existingQueries","dehydratedQuery","existingQuery","hydrationIsNewer","queryAlreadyQueued","find","push","length","prev","useIsFetching","filters","subscribe","notifyManager","batchCalls","onStoreChange","isFetching","useIsMutating","useMutationState","status","getResult","findAll","map","select","mutation","result","nextResult","replaceEqualDeep","schedule","difference","array1","array2","filter","includes","x","QueriesObserver","subscribable","l","observers","combinedResult","lastCombine","lastResult","_options","setQueries","onSubscribe","listeners","size","observer","onUpdate","onUnsubscribe","destroy","Set","notifyOptions","V","batch","prevObservers","newObserverMatches","findMatchingObservers","match","setOptions","defaultedQueryOptions","newObservers","newResult","getCurrentResult","hasIndexChange","some","index","hasListeners","notify","getQueries","getCurrentQuery","getObservers","getOptimisticResult","combine","matches","combineResult","r","observerResult","notifyOnChangeProps","trackResult","m","trackProp","accessedProp","input","utils","Q$","prevObserversMap","Map","defaultQueryOptions","matchingObservers","flatMap","defaultedOptions","matchedQueryHashes","unmatchedQueries","has","getObserver","currentObserver","o","modern_queryObserver","z","newOrReusedObservers","concat","sort","a","b","indexOf","replaceAt","array","value","copy","slice","listener","useQueries","isRestoring","useIsRestoring","errorResetBoundary","useQueryErrorResetBoundary","defaultedQueries","opts","_optimisticResults","ensureSuspenseTimers","ensurePreventErrorBoundaryRetry","useClearResetErrorBoundary","optimisticResult","getCombinedResult","suspensePromises","shouldAtLeastOneSuspend","shouldSuspend","queryObserver","QueryObserver","fetchOptimistic","willFetch","all","firstSingleResultWhichShouldThrow","getHasError","throwOnError","error","useSuspenseInfiniteQuery","useBaseQuery","enabled","suspense","defaultThrowOnError","InfiniteQueryObserver","useSuspenseQueries","placeholderData","useSuspenseQuery"],"sourceRoot":""}