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

package/build/lib/{Hydrate.svelte → HydrationBoundary.svelte}

@@ -1,7 +1,8 @@
 <script>import { useHydrate } from "./useHydrate";
 export let state;
 export let options = void 0;
-useHydrate(state, options);
+export let queryClient = void 0;
+useHydrate(state, options, queryClient);
 </script>
 
 <slot />

package/build/lib/HydrationBoundary.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+import type { DehydratedState, HydrateOptions, QueryClient } from '@tanstack/query-core';
+declare const __propDef: {
+    props: {
+        state: DehydratedState;
+        options?: HydrateOptions | undefined;
+        queryClient?: QueryClient | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type HydrationBoundaryProps = typeof __propDef.props;
+export declare type HydrationBoundaryEvents = typeof __propDef.events;
+export declare type HydrationBoundarySlots = typeof __propDef.slots;
+export default class HydrationBoundary extends SvelteComponentTyped<HydrationBoundaryProps, HydrationBoundaryEvents, HydrationBoundarySlots> {
+}
+export {};

package/build/lib/createBaseQuery.d.ts

@@ -1,3 +1,3 @@
-import { type QueryKey, type QueryObserver } from '@tanstack/query-core';
+import type { QueryClient, QueryKey, QueryObserver } from '@tanstack/query-core';
 import type { CreateBaseQueryOptions, CreateBaseQueryResult } from './types';
-export declare function createBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver): CreateBaseQueryResult<TData, TError>;
+export declare function createBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver, queryClient?: QueryClient): CreateBaseQueryResult<TData, TError>;

package/build/lib/createBaseQuery.js

@@ -1,11 +1,11 @@
-import { notifyManager, } from '@tanstack/query-core';
+import { notifyManager } from '@tanstack/query-core';
 import { useQueryClient } from './useQueryClient';
 import { derived, readable } from 'svelte/store';
-export function createBaseQuery(options, Observer) {
-    const queryClient = useQueryClient();
-    const defaultedOptions = queryClient.defaultQueryOptions(options);
+export function createBaseQuery(options, Observer, queryClient) {
+    const client = useQueryClient(queryClient);
+    const defaultedOptions = client.defaultQueryOptions(options);
     defaultedOptions._optimisticResults = 'optimistic';
-    let observer = new Observer(queryClient, defaultedOptions);
+    let observer = new Observer(client, defaultedOptions);
     // Include callbacks in batch renders
     if (defaultedOptions.onError) {
         defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);

package/build/lib/createInfiniteQuery.d.ts

@@ -1,5 +1,3 @@
-import { type QueryFunction, type QueryKey } from '@tanstack/query-core';
+import type { QueryKey, QueryClient, RegisteredError, InfiniteData } from '@tanstack/query-core';
 import type { CreateInfiniteQueryOptions, CreateInfiniteQueryResult } from './types';
-export declare function createInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>): CreateInfiniteQueryResult<TData, TError>;
-export declare 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 declare 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 declare function createInfiniteQuery<TQueryFnData, TError = RegisteredError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>, queryClient?: QueryClient): CreateInfiniteQueryResult<TData, TError>;

package/build/lib/createInfiniteQuery.js

@@ -1,6 +1,5 @@
-import { InfiniteQueryObserver, parseQueryArgs, } from '@tanstack/query-core';
+import { InfiniteQueryObserver } from '@tanstack/query-core';
 import { createBaseQuery } from './createBaseQuery';
-export function createInfiniteQuery(arg1, arg2, arg3) {
-    const options = parseQueryArgs(arg1, arg2, arg3);
-    return createBaseQuery(options, InfiniteQueryObserver);
+export function createInfiniteQuery(options, queryClient) {
+    return createBaseQuery(options, InfiniteQueryObserver, queryClient);
 }

package/build/lib/createMutation.d.ts

@@ -1,6 +1,3 @@
-import { type MutationFunction, type MutationKey } from '@tanstack/query-core';
+import type { QueryClient, RegisteredError } from '@tanstack/query-core';
 import type { CreateMutationOptions, CreateMutationResult } from './types';
-export declare function createMutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(options: CreateMutationOptions<TData, TError, TVariables, TContext>): CreateMutationResult<TData, TError, TVariables, TContext>;
-export declare 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 declare 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 declare 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 declare function createMutation<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown>(options: CreateMutationOptions<TData, TError, TVariables, TContext>, queryClient?: QueryClient): CreateMutationResult<TData, TError, TVariables, TContext>;

package/build/lib/createMutation.js

@@ -1,10 +1,9 @@
 import { readable, derived } from 'svelte/store';
-import { MutationObserver, notifyManager, parseMutationArgs, } from '@tanstack/query-core';
+import { MutationObserver, notifyManager } from '@tanstack/query-core';
 import { useQueryClient } from './useQueryClient';
-export function createMutation(arg1, arg2, arg3) {
-    const options = parseMutationArgs(arg1, arg2, arg3);
-    const queryClient = useQueryClient();
-    let observer = new MutationObserver(queryClient, options);
+export function createMutation(options, queryClient) {
+    const client = useQueryClient(queryClient);
+    let observer = new MutationObserver(client, options);
     let mutate;
     readable(observer).subscribe(($observer) => {
         observer = $observer;

package/build/lib/createQueries.d.ts

@@ -1,7 +1,9 @@
-import type { QueryKey, QueryFunction, QueryObserverResult } from '@tanstack/query-core';
+import type { QueryKey, QueryFunction, QueryClient, QueriesPlaceholderDataFunction, QueryObserverResult, RegisteredError } from '@tanstack/query-core';
 import { type Readable } from 'svelte/store';
 import type { CreateQueryOptions } from './types';
-declare type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'context'>;
+declare type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData'> & {
+    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+};
 declare type MAXIMUM_DEPTH = 20;
 declare type GetOptions<T> = T extends {
     queryFnData: infer TQueryFnData;
@@ -16,9 +18,9 @@ declare type GetOptions<T> = T extends {
 } ? CreateQueryOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryOptionsForCreateQueries<TQueryFnData> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
     select: (data: any) => infer TData;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, unknown, TData, TQueryKey> : T extends {
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TData, TQueryKey> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, unknown, TQueryFnData, TQueryKey> : CreateQueryOptionsForCreateQueries;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TQueryFnData, TQueryKey> : CreateQueryOptionsForCreateQueries;
 declare type GetResults<T> = T extends {
     queryFnData: any;
     error?: infer TError;
@@ -42,7 +44,10 @@ export declare type QueriesOptions<T extends any[], Result extends any[] = [], D
 /**
  * QueriesResults reducer recursively maps type param to results
  */
-export declare type QueriesResults<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? QueryObserverResult[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]> : T extends CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, any>[] ? QueryObserverResult<unknown extends TData ? TQueryFnData : TData, TError>[] : QueryObserverResult[];
+export declare type QueriesResults<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? QueryObserverResult[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]> : T extends CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, any>[] ? QueryObserverResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? RegisteredError : TError>[] : QueryObserverResult[];
 export declare type CreateQueriesResult<T extends any[]> = Readable<QueriesResults<T>>;
-export declare function createQueries<T extends any[]>(queries: readonly [...QueriesOptions<T>]): CreateQueriesResult<T>;
+export declare function createQueries<T extends any[]>({ queries, queryClient, }: {
+    queries: readonly [...QueriesOptions<T>];
+    queryClient?: QueryClient;
+}): CreateQueriesResult<T>;
 export {};

package/build/lib/createQueries.js

@@ -1,8 +1,8 @@
 import { notifyManager, QueriesObserver } from '@tanstack/query-core';
 import { readable } from 'svelte/store';
 import { useQueryClient } from './useQueryClient';
-export function createQueries(queries) {
-    const client = useQueryClient();
+export function createQueries({ queries, queryClient, }) {
+    const client = useQueryClient(queryClient);
     // const isRestoring = useIsRestoring()
     function getDefaultQuery(newQueries) {
         return newQueries.map((options) => {

package/build/lib/createQuery.d.ts

@@ -1,23 +1,11 @@
-import type { QueryFunction, QueryKey } from '@tanstack/query-core';
+import type { QueryKey, QueryClient, RegisteredError } from '@tanstack/query-core';
 import type { DefinedCreateQueryResult, CreateQueryOptions, CreateQueryResult } from './types';
-export declare 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 declare function createQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'initialData'> & {
+declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData?: undefined;
+};
+declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
     initialData: TQueryFnData | (() => TQueryFnData);
-}): DefinedCreateQueryResult<TData, TError>;
-export declare function createQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>): CreateQueryResult<TData, TError>;
-export declare 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 declare function createQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'initialData'> & {
-    initialData: TQueryFnData | (() => TQueryFnData);
-}): DefinedCreateQueryResult<TData, TError>;
-export declare function createQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>): CreateQueryResult<TData, TError>;
-export declare 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' | 'initialData'> & {
-    initialData?: () => undefined;
-}): CreateQueryResult<TData, TError>;
-export declare 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' | 'initialData'> & {
-    initialData: TQueryFnData | (() => TQueryFnData);
-}): DefinedCreateQueryResult<TData, TError>;
-export declare 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 declare function createQuery<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): CreateQueryResult<TData, TError>;
+export declare function createQuery<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedCreateQueryResult<TData, TError>;
+export {};

package/build/lib/createQuery.js

@@ -1,7 +1,5 @@
-import { QueryObserver, parseQueryArgs } from '@tanstack/query-core';
+import { QueryObserver } from '@tanstack/query-core';
 import { createBaseQuery } from './createBaseQuery';
-export function createQuery(arg1, arg2, arg3) {
-    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
-    const result = createBaseQuery(parsedOptions, QueryObserver);
-    return result;
+export function createQuery(options, queryClient) {
+    return createBaseQuery(options, QueryObserver, queryClient);
 }

package/build/lib/index.d.ts

@@ -8,5 +8,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/build/lib/index.js

@@ -11,5 +11,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/build/lib/types.d.ts

@@ -1,4 +1,4 @@
-import type { InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutationObserverResult, QueryObserverOptions, QueryObserverResult, QueryKey, MutationObserverOptions, MutateFunction, DefinedQueryObserverResult } from '@tanstack/query-core';
+import type { InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutationObserverResult, QueryObserverOptions, QueryObserverResult, QueryKey, MutationObserverOptions, MutateFunction, DefinedQueryObserverResult, RegisteredError } from '@tanstack/query-core';
 import type { QueryClient } from '@tanstack/query-core';
 import type { Readable } from 'svelte/store';
 export interface ContextOptions {
@@ -7,29 +7,29 @@ export interface ContextOptions {
      */
     context?: QueryClient | undefined;
 }
-export interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends ContextOptions, QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
+export interface CreateBaseQueryOptions<TQueryFnData = 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, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
+export interface CreateQueryOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
 }
-export interface CreateQueryResult<TData = unknown, TError = unknown> extends CreateBaseQueryResult<TData, TError> {
+export interface CreateQueryResult<TData = unknown, TError = RegisteredError> extends CreateBaseQueryResult<TData, TError> {
 }
-export interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
+export interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam> {
 }
-export declare type CreateInfiniteQueryResult<TData = unknown, TError = unknown> = Readable<InfiniteQueryObserverResult<TData, TError>>;
-export declare type DefinedCreateBaseQueryResult<TData = unknown, TError = unknown> = Readable<DefinedQueryObserverResult<TData, TError>>;
-export declare type DefinedCreateQueryResult<TData = unknown, TError = unknown> = DefinedCreateBaseQueryResult<TData, TError>;
-export interface CreateMutationOptions<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends ContextOptions, Omit<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted' | 'variables'> {
+export declare type CreateInfiniteQueryResult<TData = unknown, TError = RegisteredError> = Readable<InfiniteQueryObserverResult<TData, TError>>;
+export declare type DefinedCreateBaseQueryResult<TData = unknown, TError = RegisteredError> = Readable<DefinedQueryObserverResult<TData, TError>>;
+export declare type DefinedCreateQueryResult<TData = unknown, TError = RegisteredError> = DefinedCreateBaseQueryResult<TData, TError>;
+export interface CreateMutationOptions<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> extends ContextOptions, Omit<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted' | 'variables'> {
 }
-export declare type CreateMutateFunction<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
-export declare type CreateMutateAsyncFunction<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
-export declare type CreateBaseMutationResult<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
+export declare type CreateMutateFunction<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
+export declare type CreateMutateAsyncFunction<TData = unknown, TError = RegisteredError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
+export declare type CreateBaseMutationResult<TData = unknown, TError = RegisteredError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
     mutate: CreateMutateFunction<TData, TError, TVariables, TContext>;
 }> & {
     mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>;
 };
-export interface CreateMutationResult<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown> extends Readable<CreateBaseMutationResult<TData, TError, TVariables, TContext>> {
+export interface CreateMutationResult<TData = unknown, TError = RegisteredError, TVariables = unknown, TContext = unknown> extends Readable<CreateBaseMutationResult<TData, TError, TVariables, TContext>> {
 }
 declare type Override<A, B> = {
     [K in keyof A]: K extends keyof B ? B[K] : A[K];

package/build/lib/useHydrate.d.ts

@@ -1,2 +1,2 @@
-import { type HydrateOptions } from '@tanstack/query-core';
-export declare function useHydrate(state?: unknown, options?: HydrateOptions): void;
+import { type HydrateOptions, type QueryClient } from '@tanstack/query-core';
+export declare function useHydrate(state?: unknown, options?: HydrateOptions, queryClient?: QueryClient): void;

package/build/lib/useHydrate.js

@@ -1,7 +1,7 @@
 import { hydrate, } from '@tanstack/query-core';
 import { useQueryClient } from './useQueryClient';
-export function useHydrate(state, options) {
-    const client = useQueryClient();
+export function useHydrate(state, options, queryClient) {
+    const client = useQueryClient(queryClient);
     if (state) {
         hydrate(client, state, options);
     }

package/build/lib/useIsFetching.d.ts

@@ -1,4 +1,3 @@
-import { type QueryFilters, type QueryKey } from '@tanstack/query-core';
+import { type QueryFilters, type QueryClient } from '@tanstack/query-core';
 import { type Readable } from 'svelte/store';
-export declare function useIsFetching(filters?: QueryFilters): Readable<number>;
-export declare function useIsFetching(queryKey?: QueryKey, filters?: QueryFilters): Readable<number>;
+export declare function useIsFetching(filters?: QueryFilters, queryClient?: QueryClient): Readable<number>;

package/build/lib/useIsFetching.js

@@ -1,9 +1,8 @@
-import { parseFilterArgs, notifyManager, } from '@tanstack/query-core';
+import { notifyManager, } from '@tanstack/query-core';
 import { readable } from 'svelte/store';
 import { useQueryClient } from './useQueryClient';
-export function useIsFetching(arg1, arg2) {
-    const [filters] = parseFilterArgs(arg1, arg2);
-    const client = useQueryClient();
+export function useIsFetching(filters, queryClient) {
+    const client = useQueryClient(queryClient);
     const cache = client.getQueryCache();
     // isFetching is the prev value initialized on mount *
     let isFetching = client.isFetching(filters);

package/build/lib/useIsMutating.d.ts

@@ -1,4 +1,3 @@
-import { type MutationFilters, type MutationKey } from '@tanstack/query-core';
+import { type MutationFilters, type QueryClient } from '@tanstack/query-core';
 import { type Readable } from 'svelte/store';
-export declare function useIsMutating(filters?: MutationFilters): Readable<number>;
-export declare function useIsMutating(mutationKey?: MutationKey, filters?: Omit<MutationFilters, 'mutationKey'>): Readable<number>;
+export declare function useIsMutating(filters?: MutationFilters, queryClient?: QueryClient): Readable<number>;

package/build/lib/useIsMutating.js

@@ -1,9 +1,8 @@
-import { notifyManager, parseMutationFilterArgs, } from '@tanstack/query-core';
+import { notifyManager, } from '@tanstack/query-core';
 import { readable } from 'svelte/store';
 import { useQueryClient } from './useQueryClient';
-export function useIsMutating(arg1, arg2) {
-    const [filters] = parseMutationFilterArgs(arg1, arg2);
-    const client = useQueryClient();
+export function useIsMutating(filters, queryClient) {
+    const client = useQueryClient(queryClient);
     const cache = client.getMutationCache();
     // isMutating is the prev value initialized on mount *
     let isMutating = client.isMutating(filters);

package/build/lib/useQueryClient.d.ts

@@ -1,2 +1,2 @@
 import type { QueryClient } from '@tanstack/query-core';
-export declare function useQueryClient(): QueryClient;
+export declare function useQueryClient(queryClient?: QueryClient): QueryClient;

package/build/lib/useQueryClient.js

@@ -1,5 +1,8 @@
 import { getQueryClientContext } from './context';
-export function useQueryClient() {
-    const queryClient = getQueryClientContext();
-    return queryClient;
+export function useQueryClient(queryClient) {
+    const client = getQueryClientContext();
+    if (queryClient) {
+        return queryClient;
+    }
+    return client;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/svelte-query",
-  "version": "4.24.9",
+  "version": "5.0.0-alpha.0",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Svelte",
   "author": "Dre Johnson",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "vitest": "^0.27.1"
   },
   "dependencies": {
-    "@tanstack/query-core": "4.24.9"
+    "@tanstack/query-core": "5.0.0-alpha.0"
   },
   "peerDependencies": {
     "svelte": "^3.54.0"

package/src/HydrationBoundary.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+  import type {
+    DehydratedState,
+    HydrateOptions,
+    QueryClient,
+  } from '@tanstack/query-core'
+  import { useHydrate } from './useHydrate'
+
+  export let state: DehydratedState
+  export let options: HydrateOptions | undefined = undefined
+  export let queryClient: QueryClient | undefined = undefined
+
+  useHydrate(state, options, queryClient)
+</script>
+
+<slot />

package/src/__tests__/CreateQueries.svelte

@@ -3,7 +3,7 @@
   import { setQueryClientContext } from '../context'
   import type { QueriesOptions } from '../createQueries'
 
-  export let options: readonly [...QueriesOptions<any>]
+  export let options: { queries: readonly [...QueriesOptions<any>] }
 
   const queryClient = new QueryClient()
   setQueryClientContext(queryClient)
@@ -11,8 +11,10 @@
   const queries = createQueries(options)
 </script>
 
-{#each $queries as query}
-  {#if query.isSuccess}
+{#each $queries as query, index}
+  {#if query.isPending}
+    <p>Loading {index + 1}</p>
+  {:else if query.isSuccess}
     <p>{query.data}</p>
   {/if}
 {/each}

package/src/__tests__/CreateQuery.svelte

@@ -2,7 +2,7 @@
   import { createQuery, QueryClient, type CreateQueryOptions } from '../index'
   import { setQueryClientContext } from '../context'
 
-  export let options: CreateQueryOptions
+  export let options: CreateQueryOptions<any>
 
   const queryClient = new QueryClient()
   setQueryClientContext(queryClient)
@@ -10,7 +10,7 @@
   const query = createQuery(options)
 </script>
 
-{#if $query.isLoading}
+{#if $query.isPending}
   <p>Loading</p>
 {:else if $query.isError}
   <p>Error</p>

package/src/__tests__/createQueries.test.ts

@@ -1,37 +1,41 @@
 import { describe, it, expect } from 'vitest'
-import { render, screen } from '@testing-library/svelte'
+import { render, waitFor } from '@testing-library/svelte'
 import CreateQueries from './CreateQueries.svelte'
 import { sleep } from './utils'
 
 describe('createQueries', () => {
   it('Render and wait for success', async () => {
-    render(CreateQueries, {
+    const rendered = render(CreateQueries, {
       props: {
-        options: [
-          {
-            queryKey: ['key-1'],
-            queryFn: async () => {
-              await sleep(10)
-              return 'Success 1'
+        options: {
+          queries: [
+            {
+              queryKey: ['key-1'],
+              queryFn: async () => {
+                await sleep(10)
+                return 'Success 1'
+              },
             },
-          },
-          {
-            queryKey: ['key-2'],
-            queryFn: async () => {
-              await sleep(10)
-              return 'Success 2'
+            {
+              queryKey: ['key-2'],
+              queryFn: async () => {
+                await sleep(10)
+                return 'Success 2'
+              },
             },
-          },
-        ],
+          ],
+        },
       },
     })
 
-    expect(screen.queryByText('Success 1')).not.toBeInTheDocument()
-    expect(screen.queryByText('Success 2')).not.toBeInTheDocument()
-
-    await sleep(20)
+    await waitFor(() => {
+      expect(rendered.getByText('Loading 1')).toBeInTheDocument()
+      expect(rendered.getByText('Loading 2')).toBeInTheDocument()
+    })
 
-    expect(screen.queryByText('Success 1')).toBeInTheDocument()
-    expect(screen.queryByText('Success 2')).toBeInTheDocument()
+    await waitFor(() => {
+      expect(rendered.getByText('Success 1')).toBeInTheDocument()
+      expect(rendered.getByText('Success 2')).toBeInTheDocument()
+    })
   })
 })

package/src/__tests__/utils.ts

@@ -1,14 +1,9 @@
 import { vi } from 'vitest'
 import { act } from '@testing-library/svelte'
-import {
-  QueryClient,
-  type QueryClientConfig,
-  type MutationOptions,
-} from '../index'
+import { QueryClient, type QueryClientConfig } from '../index'
 
 export function createQueryClient(config?: QueryClientConfig): QueryClient {
-  vi.spyOn(console, 'error').mockImplementation(() => undefined)
-  return new QueryClient({ logger: mockLogger, ...config })
+  return new QueryClient(config)
 }
 
 export function mockVisibilityState(value: DocumentVisibilityState) {
@@ -19,12 +14,6 @@ export function mockNavigatorOnLine(value: boolean) {
   return vi.spyOn(navigator, 'onLine', 'get').mockReturnValue(value)
 }
 
-export const mockLogger = {
-  log: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn(),
-}
-
 let queryKeyCount = 0
 export function queryKey(): Array<string> {
   queryKeyCount++
@@ -49,24 +38,3 @@ export function setActTimeout(fn: () => void, ms?: number) {
     })
   }, ms)
 }
-
-/**
- * Assert the parameter is of a specific type.
- */
-export function expectType<T>(_: T): void {
-  return undefined
-}
-
-/**
- * Assert the parameter is not typed as `any`
- */
-export function expectTypeNotAny<T>(_: 0 extends 1 & T ? never : T): void {
-  return undefined
-}
-
-export function executeMutation(
-  queryClient: QueryClient,
-  options: MutationOptions<any, any, any, any>,
-): Promise<unknown> {
-  return queryClient.getMutationCache().build(queryClient, options).execute()
-}

package/src/createBaseQuery.ts

@@ -1,8 +1,5 @@
-import {
-  notifyManager,
-  type QueryKey,
-  type QueryObserver,
-} from '@tanstack/query-core'
+import type { QueryClient, QueryKey, QueryObserver } from '@tanstack/query-core'
+import { notifyManager } from '@tanstack/query-core'
 import type { CreateBaseQueryOptions, CreateBaseQueryResult } from './types'
 import { useQueryClient } from './useQueryClient'
 import { derived, readable } from 'svelte/store'
@@ -22,9 +19,10 @@ export function createBaseQuery<
     TQueryKey
   >,
   Observer: typeof QueryObserver,
+  queryClient?: QueryClient,
 ): CreateBaseQueryResult<TData, TError> {
-  const queryClient = useQueryClient()
-  const defaultedOptions = queryClient.defaultQueryOptions(options)
+  const client = useQueryClient(queryClient)
+  const defaultedOptions = client.defaultQueryOptions(options)
   defaultedOptions._optimisticResults = 'optimistic'
 
   let observer = new Observer<
@@ -33,7 +31,7 @@ export function createBaseQuery<
     TData,
     TQueryData,
     TQueryKey
-  >(queryClient, defaultedOptions)
+  >(client, defaultedOptions)
 
   // Include callbacks in batch renders
   if (defaultedOptions.onError) {