@tanstack/svelte-query 4.21.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/lib/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+node_modules
+/build
+/.svelte-kit
+/package
+.env
+.env.*
+!.env.example
+!lib/

package/build/lib/Hydrate.svelte

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

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

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

package/build/lib/QueryClientProvider.svelte

@@ -0,0 +1,14 @@
+<script>import { onMount, onDestroy } from "svelte";
+import { QueryClient } from "@tanstack/query-core";
+import { setQueryClientContext } from "./context";
+export let client = new QueryClient();
+onMount(() => {
+  client.mount();
+});
+setQueryClientContext(client);
+onDestroy(() => {
+  client.unmount();
+});
+</script>
+
+<slot />

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

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+import { QueryClient } from '@tanstack/query-core';
+declare const __propDef: {
+    props: {
+        client?: QueryClient | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type QueryClientProviderProps = typeof __propDef.props;
+export declare type QueryClientProviderEvents = typeof __propDef.events;
+export declare type QueryClientProviderSlots = typeof __propDef.slots;
+export default class QueryClientProvider extends SvelteComponentTyped<QueryClientProviderProps, QueryClientProviderEvents, QueryClientProviderSlots> {
+}
+export {};

package/build/lib/context.d.ts

@@ -0,0 +1,5 @@
+import type { QueryClient } from '@tanstack/query-core';
+/** Retrieves a Client from Svelte's context */
+export declare const getQueryClientContext: () => QueryClient;
+/** Sets a QueryClient on Svelte's context */
+export declare const setQueryClientContext: (client: QueryClient) => void;

package/build/lib/context.js

@@ -0,0 +1,14 @@
+import { setContext, getContext } from 'svelte';
+const _contextKey = '$$_queryClient';
+/** Retrieves a Client from Svelte's context */
+export const getQueryClientContext = () => {
+    const client = getContext(_contextKey);
+    if (!client) {
+        throw new Error('No QueryClient was found in Svelte context. Did you forget to wrap your component with QueryClientProvider?');
+    }
+    return client;
+};
+/** Sets a QueryClient on Svelte's context */
+export const setQueryClientContext = (client) => {
+    setContext(_contextKey, client);
+};

package/build/lib/createBaseQuery.d.ts

@@ -0,0 +1,5 @@
+import { type QueryKey, type QueryObserver } from '@tanstack/query-core';
+import type { CreateBaseQueryOptions } from './types';
+export declare function createBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver): {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<import("@tanstack/query-core").QueryObserverResult<TData, TError>>, invalidate?: ((value?: import("@tanstack/query-core").QueryObserverResult<TData, TError> | undefined) => void) | undefined) => import("svelte/store").Unsubscriber;
+};

package/build/lib/createBaseQuery.js

@@ -0,0 +1,35 @@
+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;
+        // 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 });
+    });
+    const result = readable(observer.getCurrentResult(), (set) => {
+        return observer.subscribe(notifyManager.batchCalls(set));
+    });
+    const { subscribe } = derived(result, ($result) => {
+        $result = observer.getOptimisticResult(defaultedOptions);
+        return !defaultedOptions.notifyOnChangeProps
+            ? observer.trackResult($result)
+            : $result;
+    });
+    return { subscribe };
+}

package/build/lib/createInfiniteQuery.d.ts

@@ -0,0 +1,5 @@
+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>;

package/build/lib/createInfiniteQuery.js

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

package/build/lib/createMutation.d.ts

@@ -0,0 +1,6 @@
+import { type MutationFunction, type MutationKey } from '@tanstack/query-core';
+import type { CreateMutationOptions, MutationStoreResult } from './types';
+export declare function createMutation<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown>(options: CreateMutationOptions<TData, TError, TVariables, TContext>): MutationStoreResult<TData, TError, TVariables, TContext>;
+export declare function createMutation<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown>(mutationFn: MutationFunction<TData, TVariables>, options?: Omit<CreateMutationOptions<TData, TError, TVariables, TContext>, 'mutationFn'>): MutationStoreResult<TData, TError, TVariables, TContext>;
+export declare function createMutation<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown>(mutationKey: MutationKey, options?: Omit<CreateMutationOptions<TData, TError, TVariables, TContext>, 'mutationKey'>): MutationStoreResult<TData, TError, TVariables, TContext>;
+export declare function createMutation<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown>(mutationKey: MutationKey, mutationFn?: MutationFunction<TData, TVariables>, options?: Omit<CreateMutationOptions<TData, TError, TVariables, TContext>, 'mutationKey' | 'mutationFn'>): MutationStoreResult<TData, TError, TVariables, TContext>;

package/build/lib/createMutation.js

@@ -0,0 +1,27 @@
+import { readable, derived } from 'svelte/store';
+import { MutationObserver, notifyManager, parseMutationArgs, } 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);
+    let mutate;
+    readable(observer).subscribe(($observer) => {
+        observer = $observer;
+        mutate = (variables, mutateOptions) => {
+            observer.mutate(variables, mutateOptions).catch(noop);
+        };
+        observer.setOptions(options);
+    });
+    const result = readable(observer.getCurrentResult(), (set) => {
+        return observer.subscribe(notifyManager.batchCalls((val) => set(val)));
+    });
+    const { subscribe } = derived(result, ($result) => ({
+        ...$result,
+        mutate,
+        mutateAsync: $result.mutate,
+    }));
+    return { subscribe };
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() { }

package/build/lib/createQueries.d.ts

@@ -0,0 +1,48 @@
+import type { QueryKey, QueryFunction } from '@tanstack/query-core';
+import { type Readable } from 'svelte/store';
+import type { CreateQueryOptions, CreateQueryResult } from './types';
+declare type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'context'>;
+declare type MAXIMUM_DEPTH = 20;
+declare type GetOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? 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 {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, unknown, TQueryFnData, TQueryKey> : CreateQueryOptionsForCreateQueries;
+declare type GetResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? CreateQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? CreateQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? CreateQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? CreateQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? CreateQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<unknown, any>;
+    select: (data: any) => infer TData;
+} ? CreateQueryResult<TData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+} ? CreateQueryResult<TQueryFnData> : CreateQueryResult;
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+export declare type QueriesOptions<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? CreateQueryOptionsForCreateQueries[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]> : unknown[] extends T ? T : T extends CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>[] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>[] : CreateQueryOptionsForCreateQueries[];
+/**
+ * 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 ? CreateQueryResult[] : 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>[] ? CreateQueryResult<unknown extends TData ? TQueryFnData : TData, TError>[] : CreateQueryResult[];
+export declare type CreateQueriesResult<T extends any[]> = Readable<QueriesResults<T>>;
+export declare function createQueries<T extends any[]>(queries: readonly [...QueriesOptions<T>]): CreateQueriesResult<T>;
+export {};

package/build/lib/createQueries.js

@@ -0,0 +1,27 @@
+import { notifyManager, QueriesObserver } from '@tanstack/query-core';
+import { readable } from 'svelte/store';
+import { useQueryClient } from './useQueryClient';
+export function createQueries(queries) {
+    const client = useQueryClient();
+    // const isRestoring = useIsRestoring()
+    function getDefaultQuery(newQueries) {
+        return newQueries.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;
+        // 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 });
+    });
+    const { subscribe } = readable(observer.getOptimisticResult(defaultedQueries), (set) => {
+        return observer.subscribe(notifyManager.batchCalls(set));
+    });
+    return { subscribe };
+}

package/build/lib/createQuery.d.ts

@@ -0,0 +1,23 @@
+import type { QueryFunction, QueryKey } from '@tanstack/query-core';
+import type { DefinedCreateQueryResult, CreateQueryOptions, CreateQueryStoreResult } 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;
+}): CreateQueryStoreResult<TData, TError>;
+export declare 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 declare function createQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>): CreateQueryStoreResult<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;
+}): CreateQueryStoreResult<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'>): CreateQueryStoreResult<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;
+}): CreateQueryStoreResult<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'>): CreateQueryStoreResult<TData, TError>;

package/build/lib/createQuery.js

@@ -0,0 +1,7 @@
+import { QueryObserver, parseQueryArgs } 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;
+}

package/build/lib/index.d.ts

@@ -0,0 +1,12 @@
+export * from '@tanstack/query-core';
+export * from './types';
+export { createQuery } from './createQuery';
+export { createQueries } from './createQueries';
+export { createInfiniteQuery } from './createInfiniteQuery';
+export { createMutation } from './createMutation';
+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 QueryClientProvider } from './QueryClientProvider.svelte';

package/build/lib/index.js

@@ -0,0 +1,15 @@
+/* istanbul ignore file */
+// Re-export core
+export * from '@tanstack/query-core';
+// Svelte Query
+export * from './types';
+export { createQuery } from './createQuery';
+export { createQueries } from './createQueries';
+export { createInfiniteQuery } from './createInfiniteQuery';
+export { createMutation } from './createMutation';
+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 QueryClientProvider } from './QueryClientProvider.svelte';

package/build/lib/types.d.ts

@@ -0,0 +1,40 @@
+import type { InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutationObserverResult, QueryObserverOptions, QueryObserverResult, QueryKey, MutationObserverOptions, MutateFunction, DefinedQueryObserverResult } from '@tanstack/query-core';
+import type { QueryClient } from '@tanstack/query-core';
+import type { Readable } from 'svelte/store';
+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 CreateQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
+}
+export interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
+}
+export declare type CreateInfiniteQueryResult<TData = unknown, TError = unknown> = Readable<InfiniteQueryObserverResult<TData, TError>>;
+export interface CreateInfiniteQueryStoreResult<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData> extends Readable<CreateInfiniteQueryResult<TData, TError>> {
+}
+export declare type CreateBaseQueryResult<TData = unknown, TError = unknown> = QueryObserverResult<TData, TError>;
+export declare type CreateQueryResult<TData = unknown, TError = unknown> = CreateBaseQueryResult<TData, TError>;
+export interface CreateQueryStoreResult<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData> extends Readable<CreateQueryResult<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 UseMutateFunction<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
+export declare type UseMutateAsyncFunction<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
+export declare type UseBaseMutationResult<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
+    mutate: UseMutateFunction<TData, TError, TVariables, TContext>;
+}> & {
+    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+};
+export declare type CreateMutationResult<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown> = UseBaseMutationResult<TData, TError, TVariables, TContext>;
+export interface MutationStoreResult<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown> extends Readable<CreateMutationResult<TData, TError, TVariables, TContext>> {
+}
+declare type Override<A, B> = {
+    [K in keyof A]: K extends keyof B ? B[K] : A[K];
+};
+export {};

package/build/lib/types.js

@@ -0,0 +1 @@
+export {};

package/build/lib/useHydrate.d.ts

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

package/build/lib/useHydrate.js

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

package/build/lib/useIsFetching.d.ts

@@ -0,0 +1,4 @@
+import { type QueryFilters, type QueryKey } 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>;

package/build/lib/useIsFetching.js

@@ -0,0 +1,21 @@
+import { parseFilterArgs, 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();
+    const cache = client.getQueryCache();
+    // isFetching is the prev value initialized on mount *
+    let isFetching = client.isFetching(filters);
+    const { subscribe } = readable(isFetching, (set) => {
+        return cache.subscribe(notifyManager.batchCalls(() => {
+            const newIsFetching = client.isFetching(filters);
+            if (isFetching !== newIsFetching) {
+                // * and update with each change
+                isFetching = newIsFetching;
+                set(isFetching);
+            }
+        }));
+    });
+    return { subscribe };
+}

package/build/lib/useIsMutating.d.ts

@@ -0,0 +1,4 @@
+import { type MutationFilters, type MutationKey } 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>;

package/build/lib/useIsMutating.js

@@ -0,0 +1,21 @@
+import { notifyManager, parseMutationFilterArgs, } 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();
+    const cache = client.getMutationCache();
+    // isMutating is the prev value initialized on mount *
+    let isMutating = client.isMutating(filters);
+    const { subscribe } = readable(isMutating, (set) => {
+        return cache.subscribe(notifyManager.batchCalls(() => {
+            const newIisMutating = client.isMutating(filters);
+            if (isMutating !== newIisMutating) {
+                // * and update with each change
+                isMutating = newIisMutating;
+                set(isMutating);
+            }
+        }));
+    });
+    return { subscribe };
+}

package/build/lib/useQueryClient.d.ts

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

package/build/lib/useQueryClient.js

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

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@tanstack/svelte-query",
+  "version": "4.21.0",
+  "description": "Primitives for managing, caching and syncing asynchronous and remote data in Svelte",
+  "author": "Dre Johnson",
+  "license": "MIT",
+  "repository": "tanstack/query",
+  "homepage": "https://tanstack.com/query",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "types": "build/lib/index.d.ts",
+  "module": "build/lib/index.js",
+  "type": "module",
+  "devDependencies": {
+    "@sveltejs/adapter-auto": "^1.0.0",
+    "@sveltejs/kit": "^1.0.0",
+    "@sveltejs/package": "^1.0.0",
+    "@testing-library/svelte": "^3.2.2",
+    "@vitest/coverage-istanbul": "^0.26.3",
+    "eslint-plugin-svelte": "^2.14.1",
+    "jsdom": "^20.0.3",
+    "rimraf": "^3.0.2",
+    "svelte": "^3.54.0",
+    "svelte-check": "^2.9.2",
+    "tslib": "^2.4.1",
+    "typescript": "^4.7.4",
+    "vite": "^4.0.0",
+    "vitest": "^0.26.3"
+  },
+  "dependencies": {
+    "@tanstack/query-core": "4.21.0"
+  },
+  "peerDependencies": {
+    "svelte": "^3.54.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./build/lib/index.js"
+  },
+  "svelte": "./build/lib/index.js",
+  "files": [
+    "build/lib/*",
+    "src"
+  ],
+  "scripts": {
+    "clean": "rimraf ./build",
+    "build": "svelte-kit sync && svelte-package && rimraf ./build/lib/package.json",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "test:eslint": "svelte-kit sync && ../../node_modules/.bin/eslint --ext .svelte,.ts ./src",
+    "test:jest": "svelte-kit sync && vitest run --coverage"
+  }
+}

package/src/__tests__/CreateMutation.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+  import { createMutation, QueryClient } from '../lib'
+  import { setQueryClientContext } from '../lib/context'
+
+  export let queryFn: () => Promise<string>
+
+  const queryClient = new QueryClient()
+  setQueryClientContext(queryClient)
+
+  const mutation = createMutation(queryFn)
+</script>
+
+<button on:click={$mutation.mutate}>Click</button>

package/src/__tests__/CreateQuery.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+  import { createQuery, QueryClient } from '../lib'
+  import { setQueryClientContext } from '../lib/context'
+
+  export let queryKey: Array<string>
+  export let queryFn: () => Promise<string>
+
+  const queryClient = new QueryClient()
+  setQueryClientContext(queryClient)
+
+  const query = createQuery({
+    queryKey,
+    queryFn,
+  })
+</script>
+
+{#if $query.isLoading}
+  <p>Loading</p>
+{:else if $query.isError}
+  <p>Error</p>
+{:else if $query.isSuccess}
+  <p>Success</p>
+{/if}

package/src/__tests__/createMutation.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect, vi } from 'vitest'
+import { fireEvent, render, screen } from '@testing-library/svelte'
+import CreateMutation from './CreateMutation.svelte'
+import { sleep } from './utils'
+
+describe('createMutation', () => {
+  it('Call mutate and check function runs', async () => {
+    const queryFn = vi.fn()
+
+    render(CreateMutation, {
+      props: {
+        queryFn,
+      },
+    })
+
+    fireEvent.click(screen.getByRole('button'))
+
+    await sleep(200)
+
+    expect(queryFn).toHaveBeenCalledTimes(1)
+  })
+})