@tanstack/svelte-query 4.24.9 → 5.0.0-alpha.0

package/src/createInfiniteQuery.ts

@@ -1,103 +1,37 @@
-import {
-  InfiniteQueryObserver,
-  parseQueryArgs,
-  type QueryObserver,
-  type QueryFunction,
-  type QueryKey,
+import type {
+  QueryObserver,
+  QueryKey,
+  QueryClient,
+  RegisteredError,
+  InfiniteData,
 } from '@tanstack/query-core'
+import { InfiniteQueryObserver } from '@tanstack/query-core'
 import type {
   CreateInfiniteQueryOptions,
   CreateInfiniteQueryResult,
 } from './types'
 import { createBaseQuery } from './createBaseQuery'
 
-export function createInfiniteQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: CreateInfiniteQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryFnData,
-    TQueryKey
-  >,
-): CreateInfiniteQueryResult<TData, TError>
-export function createInfiniteQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  queryKey: TQueryKey,
-  options?: Omit<
-    CreateInfiniteQueryOptions<
-      TQueryFnData,
-      TError,
-      TData,
-      TQueryFnData,
-      TQueryKey
-    >,
-    'queryKey'
-  >,
-): CreateInfiniteQueryResult<TData, TError>
-export function createInfiniteQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  queryKey: TQueryKey,
-  queryFn: QueryFunction<TQueryFnData, TQueryKey>,
-  options?: Omit<
-    CreateInfiniteQueryOptions<
-      TQueryFnData,
-      TError,
-      TData,
-      TQueryFnData,
-      TQueryKey
-    >,
-    'queryKey' | 'queryFn'
-  >,
-): CreateInfiniteQueryResult<TData, TError>
-
 export function createInfiniteQuery<
   TQueryFnData,
-  TError,
-  TData = TQueryFnData,
+  TError = RegisteredError,
+  TData = InfiniteData<TQueryFnData>,
   TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
 >(
-  arg1:
-    | TQueryKey
-    | CreateInfiniteQueryOptions<
-        TQueryFnData,
-        TError,
-        TData,
-        TQueryFnData,
-        TQueryKey
-      >,
-  arg2?:
-    | QueryFunction<TQueryFnData, TQueryKey>
-    | CreateInfiniteQueryOptions<
-        TQueryFnData,
-        TError,
-        TData,
-        TQueryFnData,
-        TQueryKey
-      >,
-  arg3?: CreateInfiniteQueryOptions<
+  options: CreateInfiniteQueryOptions<
     TQueryFnData,
     TError,
     TData,
     TQueryFnData,
-    TQueryKey
+    TQueryKey,
+    TPageParam
   >,
+  queryClient?: QueryClient,
 ): CreateInfiniteQueryResult<TData, TError> {
-  const options = parseQueryArgs(arg1, arg2, arg3)
   return createBaseQuery(
     options,
     InfiniteQueryObserver as typeof QueryObserver,
+    queryClient,
   ) as CreateInfiniteQueryResult<TData, TError>
 }

package/src/createMutation.ts

@@ -1,11 +1,6 @@
 import { readable, derived } from 'svelte/store'
-import {
-  type MutationFunction,
-  type MutationKey,
-  MutationObserver,
-  notifyManager,
-  parseMutationArgs,
-} from '@tanstack/query-core'
+import type { QueryClient, RegisteredError } from '@tanstack/query-core'
+import { MutationObserver, notifyManager } from '@tanstack/query-core'
 import type {
   CreateMutateFunction,
   CreateMutationOptions,
@@ -15,72 +10,16 @@ import { useQueryClient } from './useQueryClient'
 
 export function createMutation<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = void,
   TContext = unknown,
 >(
   options: CreateMutationOptions<TData, TError, TVariables, TContext>,
-): CreateMutationResult<TData, TError, TVariables, TContext>
-
-export function createMutation<
-  TData = unknown,
-  TError = unknown,
-  TVariables = void,
-  TContext = unknown,
->(
-  mutationFn: MutationFunction<TData, TVariables>,
-  options?: Omit<
-    CreateMutationOptions<TData, TError, TVariables, TContext>,
-    'mutationFn'
-  >,
-): CreateMutationResult<TData, TError, TVariables, TContext>
-
-export function createMutation<
-  TData = unknown,
-  TError = unknown,
-  TVariables = void,
-  TContext = unknown,
->(
-  mutationKey: MutationKey,
-  options?: Omit<
-    CreateMutationOptions<TData, TError, TVariables, TContext>,
-    'mutationKey'
-  >,
-): CreateMutationResult<TData, TError, TVariables, TContext>
-
-export function createMutation<
-  TData = unknown,
-  TError = unknown,
-  TVariables = void,
-  TContext = unknown,
->(
-  mutationKey: MutationKey,
-  mutationFn?: MutationFunction<TData, TVariables>,
-  options?: Omit<
-    CreateMutationOptions<TData, TError, TVariables, TContext>,
-    'mutationKey' | 'mutationFn'
-  >,
-): CreateMutationResult<TData, TError, TVariables, TContext>
-
-export function createMutation<
-  TData = unknown,
-  TError = unknown,
-  TVariables = void,
-  TContext = unknown,
->(
-  arg1:
-    | MutationKey
-    | MutationFunction<TData, TVariables>
-    | CreateMutationOptions<TData, TError, TVariables, TContext>,
-  arg2?:
-    | MutationFunction<TData, TVariables>
-    | CreateMutationOptions<TData, TError, TVariables, TContext>,
-  arg3?: CreateMutationOptions<TData, TError, TVariables, TContext>,
+  queryClient?: QueryClient,
 ): CreateMutationResult<TData, TError, TVariables, TContext> {
-  const options = parseMutationArgs(arg1, arg2, arg3)
-  const queryClient = useQueryClient()
+  const client = useQueryClient(queryClient)
   let observer = new MutationObserver<TData, TError, TVariables, TContext>(
-    queryClient,
+    client,
     options,
   )
   let mutate: CreateMutateFunction<TData, TError, TVariables, TContext>

package/src/createQueries.ts

@@ -2,7 +2,9 @@ import type {
   QueryKey,
   QueryFunction,
   QueryClient,
+  QueriesPlaceholderDataFunction,
   QueryObserverResult,
+  RegisteredError,
 } from '@tanstack/query-core'
 
 import { notifyManager, QueriesObserver } from '@tanstack/query-core'
@@ -12,13 +14,18 @@ import type { CreateQueryOptions } from './types'
 import { useQueryClient } from './useQueryClient'
 
 // This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
-// - `context` is omitted as it is passed as a root-level option to `createQueries` instead.
+// `placeholderData` function does not have a parameter
 type CreateQueryOptionsForCreateQueries<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'context'>
+> = Omit<
+  CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  'placeholderData'
+> & {
+  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
+}
 
 // Avoid TS depth-limit error in case of large array literal
 type MAXIMUM_DEPTH = 20
@@ -47,16 +54,11 @@ type GetOptions<T> =
         queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
         select: (data: any) => infer TData
       }
-    ? CreateQueryOptionsForCreateQueries<
-        TQueryFnData,
-        unknown,
-        TData,
-        TQueryKey
-      >
+    ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TData, TQueryKey>
     : T extends { queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> }
     ? CreateQueryOptionsForCreateQueries<
         TQueryFnData,
-        unknown,
+        Error,
         TQueryFnData,
         TQueryKey
       >
@@ -140,16 +142,23 @@ export type QueriesResults<
       any
     >[]
   ? // Dynamic-size (homogenous) CreateQueryOptions array: map directly to array of results
-    QueryObserverResult<unknown extends TData ? TQueryFnData : TData, TError>[]
+    QueryObserverResult<
+      unknown extends TData ? TQueryFnData : TData,
+      unknown extends TError ? RegisteredError : TError
+    >[]
   : // Fallback
     QueryObserverResult[]
 
 export type CreateQueriesResult<T extends any[]> = Readable<QueriesResults<T>>
 
-export function createQueries<T extends any[]>(
-  queries: readonly [...QueriesOptions<T>],
-): CreateQueriesResult<T> {
-  const client: QueryClient = useQueryClient()
+export function createQueries<T extends any[]>({
+  queries,
+  queryClient,
+}: {
+  queries: readonly [...QueriesOptions<T>]
+  queryClient?: QueryClient
+}): CreateQueriesResult<T> {
+  const client = useQueryClient(queryClient)
   // const isRestoring = useIsRestoring()
 
   function getDefaultQuery(newQueries: readonly [...QueriesOptions<T>]) {

package/src/createQuery.ts

@@ -1,5 +1,9 @@
-import { QueryObserver, parseQueryArgs } from '@tanstack/query-core'
-import type { QueryFunction, QueryKey } from '@tanstack/query-core'
+import { QueryObserver } from '@tanstack/query-core'
+import type {
+  QueryKey,
+  QueryClient,
+  RegisteredError,
+} from '@tanstack/query-core'
 import { createBaseQuery } from './createBaseQuery'
 import type {
   DefinedCreateQueryResult,
@@ -7,137 +11,52 @@ import type {
   CreateQueryResult,
 } from './types'
 
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'initialData'
-  > & {
-    initialData?: () => undefined
-  },
-): CreateQueryResult<TData, TError>
-
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'initialData'
-  > & {
-    initialData: TQueryFnData | (() => TQueryFnData)
-  },
-): DefinedCreateQueryResult<TData, TError>
-
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-): CreateQueryResult<TData, TError>
-
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  queryKey: TQueryKey,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'initialData'
-  > & { initialData?: () => undefined },
-): CreateQueryResult<TData, TError>
-
-export function createQuery<
+type UndefinedInitialDataOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
->(
-  queryKey: TQueryKey,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'initialData'
-  > & { initialData: TQueryFnData | (() => TQueryFnData) },
-): DefinedCreateQueryResult<TData, TError>
+> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+  initialData?: undefined
+}
 
-export function createQuery<
+type DefinedInitialDataOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
->(
-  queryKey: TQueryKey,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey'
-  >,
-): CreateQueryResult<TData, TError>
+> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+  initialData: TQueryFnData | (() => TQueryFnData)
+}
 
 export function createQuery<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  queryKey: TQueryKey,
-  queryFn: QueryFunction<TQueryFnData, TQueryKey>,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'queryFn' | 'initialData'
-  > & { initialData?: () => undefined },
+  options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: QueryClient,
 ): CreateQueryResult<TData, TError>
 
 export function createQuery<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  queryKey: TQueryKey,
-  queryFn: QueryFunction<TQueryFnData, TQueryKey>,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'queryFn' | 'initialData'
-  > & { initialData: TQueryFnData | (() => TQueryFnData) },
+  options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: QueryClient,
 ): DefinedCreateQueryResult<TData, TError>
 
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  queryKey: TQueryKey,
-  queryFn: QueryFunction<TQueryFnData, TQueryKey>,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'queryFn'
-  >,
-): CreateQueryResult<TData, TError>
-
 export function createQuery<
   TQueryFnData,
-  TError,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  arg1: TQueryKey | CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  arg2?:
-    | QueryFunction<TQueryFnData, TQueryKey>
-    | CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  arg3?: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-): CreateQueryResult<TData, TError> {
-  const parsedOptions = parseQueryArgs(arg1, arg2, arg3)
-  const result = createBaseQuery(parsedOptions, QueryObserver)
-  return result
+  options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: QueryClient,
+) {
+  return createBaseQuery(options, QueryObserver, queryClient)
 }

package/src/index.ts

@@ -13,5 +13,5 @@ export { useQueryClient } from './useQueryClient'
 export { useIsFetching } from './useIsFetching'
 export { useIsMutating } from './useIsMutating'
 export { useHydrate } from './useHydrate'
-export { default as Hydrate } from './Hydrate.svelte'
+export { default as HydrationBoundary } from './HydrationBoundary.svelte'
 export { default as QueryClientProvider } from './QueryClientProvider.svelte'

package/src/types.ts

@@ -8,6 +8,7 @@ import type {
   MutationObserverOptions,
   MutateFunction,
   DefinedQueryObserverResult,
+  RegisteredError,
 } from '@tanstack/query-core'
 import type { QueryClient } from '@tanstack/query-core'
 import type { Readable } from 'svelte/store'
@@ -21,19 +22,21 @@ export interface ContextOptions {
 
 export interface CreateBaseQueryOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > extends ContextOptions,
     QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {}
 
-export interface CreateBaseQueryResult<TData = unknown, TError = unknown>
-  extends Readable<QueryObserverResult<TData, TError>> {}
+export interface CreateBaseQueryResult<
+  TData = unknown,
+  TError = RegisteredError,
+> extends Readable<QueryObserverResult<TData, TError>> {}
 
 export interface CreateQueryOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > extends CreateBaseQueryOptions<
@@ -44,41 +47,43 @@ export interface CreateQueryOptions<
     TQueryKey
   > {}
 
-export interface CreateQueryResult<TData = unknown, TError = unknown>
+export interface CreateQueryResult<TData = unknown, TError = RegisteredError>
   extends CreateBaseQueryResult<TData, TError> {}
 
 export interface CreateInfiniteQueryOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
 > extends InfiniteQueryObserverOptions<
     TQueryFnData,
     TError,
     TData,
     TQueryData,
-    TQueryKey
+    TQueryKey,
+    TPageParam
   > {}
 
 export type CreateInfiniteQueryResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
 > = Readable<InfiniteQueryObserverResult<TData, TError>>
 
 export type DefinedCreateBaseQueryResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
 > = Readable<DefinedQueryObserverResult<TData, TError>>
 
 export type DefinedCreateQueryResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
 > = DefinedCreateBaseQueryResult<TData, TError>
 
 export interface CreateMutationOptions<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = void,
   TContext = unknown,
 > extends ContextOptions,
@@ -89,7 +94,7 @@ export interface CreateMutationOptions<
 
 export type CreateMutateFunction<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = void,
   TContext = unknown,
 > = (
@@ -98,14 +103,14 @@ export type CreateMutateFunction<
 
 export type CreateMutateAsyncFunction<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = void,
   TContext = unknown,
 > = MutateFunction<TData, TError, TVariables, TContext>
 
 export type CreateBaseMutationResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = unknown,
   TContext = unknown,
 > = Override<
@@ -117,7 +122,7 @@ export type CreateBaseMutationResult<
 
 export interface CreateMutationResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = unknown,
   TContext = unknown,
 > extends Readable<

package/src/useHydrate.ts

@@ -5,8 +5,12 @@ import {
 } from '@tanstack/query-core'
 import { useQueryClient } from './useQueryClient'
 
-export function useHydrate(state?: unknown, options?: HydrateOptions) {
-  const client: QueryClient = useQueryClient()
+export function useHydrate(
+  state?: unknown,
+  options?: HydrateOptions,
+  queryClient?: QueryClient,
+) {
+  const client = useQueryClient(queryClient)
 
   if (state) {
     hydrate(client, state, options)

package/src/useIsFetching.ts

@@ -1,25 +1,16 @@
 import {
   type QueryFilters,
-  type QueryKey,
   type QueryClient,
-  parseFilterArgs,
   notifyManager,
 } from '@tanstack/query-core'
 import { type Readable, readable } from 'svelte/store'
 import { useQueryClient } from './useQueryClient'
 
-export function useIsFetching(filters?: QueryFilters): Readable<number>
 export function useIsFetching(
-  queryKey?: QueryKey,
   filters?: QueryFilters,
-): Readable<number>
-
-export function useIsFetching(
-  arg1?: QueryKey | QueryFilters,
-  arg2?: QueryFilters,
+  queryClient?: QueryClient,
 ): Readable<number> {
-  const [filters] = parseFilterArgs(arg1, arg2)
-  const client: QueryClient = useQueryClient()
+  const client = useQueryClient(queryClient)
   const cache = client.getQueryCache()
   // isFetching is the prev value initialized on mount *
   let isFetching = client.isFetching(filters)

package/src/useIsMutating.ts

@@ -1,25 +1,16 @@
 import {
   type MutationFilters,
-  type MutationKey,
   type QueryClient,
   notifyManager,
-  parseMutationFilterArgs,
 } from '@tanstack/query-core'
 import { type Readable, readable } from 'svelte/store'
 import { useQueryClient } from './useQueryClient'
 
-export function useIsMutating(filters?: MutationFilters): Readable<number>
 export function useIsMutating(
-  mutationKey?: MutationKey,
-  filters?: Omit<MutationFilters, 'mutationKey'>,
-): Readable<number>
-
-export function useIsMutating(
-  arg1?: MutationKey | MutationFilters,
-  arg2?: Omit<MutationFilters, 'mutationKey'>,
+  filters?: MutationFilters,
+  queryClient?: QueryClient,
 ): Readable<number> {
-  const [filters] = parseMutationFilterArgs(arg1, arg2)
-  const client: QueryClient = useQueryClient()
+  const client = useQueryClient(queryClient)
   const cache = client.getMutationCache()
   // isMutating is the prev value initialized on mount *
   let isMutating = client.isMutating(filters)

package/src/useQueryClient.ts

@@ -1,7 +1,12 @@
 import type { QueryClient } from '@tanstack/query-core'
 import { getQueryClientContext } from './context'
 
-export function useQueryClient(): QueryClient {
-  const queryClient = getQueryClientContext()
-  return queryClient
+export function useQueryClient(queryClient?: QueryClient): QueryClient {
+  const client = getQueryClientContext()
+
+  if (queryClient) {
+    return queryClient
+  }
+
+  return client
 }