@tanstack/svelte-query 4.24.10 → 5.0.0-alpha.1

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

package/build/lib/createBaseQuery.js

@@ -1,33 +1,37 @@
-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);
-    defaultedOptions._optimisticResults = 'optimistic';
-    let observer = new Observer(queryClient, defaultedOptions);
-    // Include callbacks in batch renders
-    if (defaultedOptions.onError) {
-        defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);
-    }
-    if (defaultedOptions.onSuccess) {
-        defaultedOptions.onSuccess = notifyManager.batchCalls(defaultedOptions.onSuccess);
-    }
-    if (defaultedOptions.onSettled) {
-        defaultedOptions.onSettled = notifyManager.batchCalls(defaultedOptions.onSettled);
-    }
-    readable(observer).subscribe(($observer) => {
-        observer = $observer;
+import { derived, get, readable, writable } from 'svelte/store';
+import { isWritable } from './utils';
+export function createBaseQuery(options, Observer, queryClient) {
+    const client = useQueryClient(queryClient);
+    const optionsStore = isWritable(options) ? options : writable(options);
+    const defaultedOptionsStore = derived(optionsStore, ($options) => {
+        const defaultedOptions = client.defaultQueryOptions($options);
+        defaultedOptions._optimisticResults = 'optimistic';
+        // Include callbacks in batch renders
+        if (defaultedOptions.onError) {
+            defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);
+        }
+        if (defaultedOptions.onSuccess) {
+            defaultedOptions.onSuccess = notifyManager.batchCalls(defaultedOptions.onSuccess);
+        }
+        if (defaultedOptions.onSettled) {
+            defaultedOptions.onSettled = notifyManager.batchCalls(defaultedOptions.onSettled);
+        }
+        return defaultedOptions;
+    });
+    const observer = new Observer(client, get(defaultedOptionsStore));
+    defaultedOptionsStore.subscribe(($defaultedOptions) => {
         // Do not notify on updates because of changes in the options because
         // these changes should already be reflected in the optimistic result.
-        observer.setOptions(defaultedOptions, { listeners: false });
+        observer.setOptions($defaultedOptions, { listeners: false });
     });
     const result = readable(observer.getCurrentResult(), (set) => {
         return observer.subscribe(notifyManager.batchCalls(set));
     });
     const { subscribe } = derived(result, ($result) => {
-        $result = observer.getOptimisticResult(defaultedOptions);
-        return !defaultedOptions.notifyOnChangeProps
+        $result = observer.getOptimisticResult(get(defaultedOptionsStore));
+        return !get(defaultedOptionsStore).notifyOnChangeProps
             ? observer.trackResult($result)
             : $result;
     });

package/build/lib/createInfiniteQuery.d.ts

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

package/build/lib/createInfiniteQuery.js

@@ -1,6 +1,7 @@
-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, 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    InfiniteQueryObserver, queryClient);
 }

package/build/lib/createMutation.d.ts

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

package/build/lib/createMutation.js

@@ -1,17 +1,17 @@
-import { readable, derived } from 'svelte/store';
-import { MutationObserver, notifyManager, parseMutationArgs, } from '@tanstack/query-core';
+import { readable, derived, writable, get } from 'svelte/store';
+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);
+import { isWritable } from './utils';
+export function createMutation(options, queryClient) {
+    const client = useQueryClient(queryClient);
+    const optionsStore = isWritable(options) ? options : writable(options);
+    const observer = new MutationObserver(client, get(optionsStore));
     let mutate;
-    readable(observer).subscribe(($observer) => {
-        observer = $observer;
+    optionsStore.subscribe(($options) => {
         mutate = (variables, mutateOptions) => {
             observer.mutate(variables, mutateOptions).catch(noop);
         };
-        observer.setOptions(options);
+        observer.setOptions($options);
     });
     const result = readable(observer.getCurrentResult(), (set) => {
         return observer.subscribe(notifyManager.batchCalls((val) => set(val)));

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'>;
+import type { CreateQueryOptions, WritableOrVal } from './types';
+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: WritableOrVal<[...QueriesOptions<T>]>;
+    queryClient?: QueryClient;
+}): CreateQueriesResult<T>;
 export {};

package/build/lib/createQueries.js

@@ -1,26 +1,26 @@
 import { notifyManager, QueriesObserver } from '@tanstack/query-core';
-import { readable } from 'svelte/store';
+import { derived, get, readable, writable } from 'svelte/store';
 import { useQueryClient } from './useQueryClient';
-export function createQueries(queries) {
-    const client = useQueryClient();
+import { isWritable } from './utils';
+export function createQueries({ queries, queryClient, }) {
+    const client = useQueryClient(queryClient);
     // const isRestoring = useIsRestoring()
-    function getDefaultQuery(newQueries) {
-        return newQueries.map((options) => {
+    const queriesStore = isWritable(queries) ? queries : writable(queries);
+    const defaultedQueriesStore = derived(queriesStore, ($queries) => {
+        return $queries.map((options) => {
             const defaultedOptions = client.defaultQueryOptions(options);
             // Make sure the results are already in fetching state before subscribing or updating options
             defaultedOptions._optimisticResults = 'optimistic';
             return defaultedOptions;
         });
-    }
-    const defaultedQueries = getDefaultQuery(queries);
-    let observer = new QueriesObserver(client, defaultedQueries);
-    readable(observer).subscribe(($observer) => {
-        observer = $observer;
+    });
+    const observer = new QueriesObserver(client, get(defaultedQueriesStore));
+    defaultedQueriesStore.subscribe(($defaultedQueries) => {
         // Do not notify on updates because of changes in the options because
         // these changes should already be reflected in the optimistic result.
-        observer.setQueries(defaultedQueries, { listeners: false });
+        observer.setQueries($defaultedQueries, { listeners: false });
     });
-    const { subscribe } = readable(observer.getOptimisticResult(defaultedQueries), (set) => {
+    const { subscribe } = readable(observer.getOptimisticResult(get(defaultedQueriesStore)), (set) => {
         return observer.subscribe(notifyManager.batchCalls(set));
     });
     return { subscribe };

package/build/lib/createQuery.d.ts

@@ -1,23 +1,11 @@
-import type { QueryFunction, QueryKey } 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'> & {
+import type { QueryKey, QueryClient, RegisteredError } from '@tanstack/query-core';
+import type { DefinedCreateQueryResult, CreateQueryOptions, CreateQueryResult, WritableOrVal } from './types';
+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: WritableOrVal<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: WritableOrVal<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,35 +1,36 @@
-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';
+import type { Readable, Writable } from 'svelte/store';
+export declare type WritableOrVal<T> = T | Writable<T>;
 export interface ContextOptions {
     /**
      * Use this to pass your Svelte Query context. Otherwise, `defaultContext` will be used.
      */
     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/build/lib/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Writable } from 'svelte/store';
+import type { WritableOrVal } from './types';
+export declare function isWritable<T extends object>(obj: WritableOrVal<T>): obj is Writable<T>;

package/build/lib/utils.js

@@ -0,0 +1,3 @@
+export function isWritable(obj) {
+    return 'subscribe' in obj && 'set' in obj && 'update' in obj;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/svelte-query",
-  "version": "4.24.10",
+  "version": "5.0.0-alpha.1",
   "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.10"
+    "@tanstack/query-core": "5.0.0-alpha.1"
   },
   "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: [...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

@@ -1,8 +1,13 @@
 <script lang="ts">
-  import { createQuery, QueryClient, type CreateQueryOptions } from '../index'
+  import {
+    createQuery,
+    QueryClient,
+    type CreateQueryOptions,
+    type WritableOrVal,
+  } from '../index'
   import { setQueryClientContext } from '../context'
 
-  export let options: CreateQueryOptions
+  export let options: WritableOrVal<CreateQueryOptions<any>>
 
   const queryClient = new QueryClient()
   setQueryClientContext(queryClient)
@@ -10,10 +15,16 @@
   const query = createQuery(options)
 </script>
 
-{#if $query.isLoading}
+{#if $query.isPending}
   <p>Loading</p>
 {:else if $query.isError}
   <p>Error</p>
 {:else if $query.isSuccess}
   <p>Success</p>
 {/if}
+
+<ul>
+  {#each $query.data ?? [] as entry}
+    <li>id: {entry.id}</li>
+  {/each}
+</ul>