@tanstack/svelte-query 5.0.0-alpha.6 → 5.0.0-alpha.61

package/src/createQueries.ts

@@ -5,24 +5,24 @@ import type {
   QueriesPlaceholderDataFunction,
   QueryObserverResult,
   DefaultError,
+  QueriesObserverOptions,
+  QueryObserverOptions,
 } from '@tanstack/query-core'
-
 import { notifyManager, QueriesObserver } from '@tanstack/query-core'
 import { derived, get, readable, writable, type Readable } from 'svelte/store'
-
-import type { CreateQueryOptions, WritableOrVal } from './types'
+import type { WritableOrVal } from './types'
 import { useQueryClient } from './useQueryClient'
 import { isWritable } from './utils'
 
 // This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
 // `placeholderData` function does not have a parameter
-type CreateQueryOptionsForCreateQueries<
+type QueryObserverOptionsForCreateQueries<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > = Omit<
-  CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
   'placeholderData'
 > & {
   placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
@@ -38,33 +38,38 @@ type GetOptions<T> =
     error?: infer TError
     data: infer TData
   }
-    ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
+    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
     : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
-    ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
+    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
     : T extends { data: infer TData; error?: infer TError }
-    ? CreateQueryOptionsForCreateQueries<unknown, TError, TData>
+    ? QueryObserverOptionsForCreateQueries<unknown, TError, TData>
     : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
     T extends [infer TQueryFnData, infer TError, infer TData]
-    ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
+    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
     : T extends [infer TQueryFnData, infer TError]
-    ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
+    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
     : T extends [infer TQueryFnData]
-    ? CreateQueryOptionsForCreateQueries<TQueryFnData>
+    ? QueryObserverOptionsForCreateQueries<TQueryFnData>
     : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
     T extends {
         queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
         select: (data: any) => infer TData
       }
-    ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TData, TQueryKey>
+    ? QueryObserverOptionsForCreateQueries<
+        TQueryFnData,
+        Error,
+        TData,
+        TQueryKey
+      >
     : T extends { queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> }
-    ? CreateQueryOptionsForCreateQueries<
+    ? QueryObserverOptionsForCreateQueries<
         TQueryFnData,
         Error,
         TQueryFnData,
         TQueryKey
       >
     : // Fallback
-      CreateQueryOptionsForCreateQueries
+      QueryObserverOptionsForCreateQueries
 
 type GetResults<T> =
   // Part 1: responsible for mapping explicit type parameter to function result, if object
@@ -100,7 +105,7 @@ export type QueriesOptions<
   Result extends any[] = [],
   Depth extends ReadonlyArray<number> = [],
 > = Depth['length'] extends MAXIMUM_DEPTH
-  ? CreateQueryOptionsForCreateQueries[]
+  ? QueryObserverOptionsForCreateQueries[]
   : T extends []
   ? []
   : T extends [infer Head]
@@ -111,15 +116,20 @@ export type QueriesOptions<
   ? T
   : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
   // use this to infer the param types in the case of Array.map() argument
-  T extends CreateQueryOptionsForCreateQueries<
+  T extends QueryObserverOptionsForCreateQueries<
       infer TQueryFnData,
       infer TError,
       infer TData,
       infer TQueryKey
     >[]
-  ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>[]
+  ? QueryObserverOptionsForCreateQueries<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryKey
+    >[]
   : // Fallback
-    CreateQueryOptionsForCreateQueries[]
+    QueryObserverOptionsForCreateQueries[]
 
 /**
  * QueriesResults reducer recursively maps type param to results
@@ -136,7 +146,7 @@ export type QueriesResults<
   ? [...Result, GetResults<Head>]
   : T extends [infer Head, ...infer Tail]
   ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]>
-  : T extends CreateQueryOptionsForCreateQueries<
+  : T extends QueryObserverOptionsForCreateQueries<
       infer TQueryFnData,
       infer TError,
       infer TData,
@@ -150,44 +160,56 @@ export type QueriesResults<
   : // Fallback
     QueryObserverResult[]
 
-export type CreateQueriesResult<T extends any[]> = Readable<QueriesResults<T>>
-
-export function createQueries<T extends any[]>(
+export function createQueries<
+  T extends any[],
+  TCombinedResult = QueriesResults<T>,
+>(
   {
     queries,
+    ...options
   }: {
     queries: WritableOrVal<[...QueriesOptions<T>]>
+    combine?: (result: QueriesResults<T>) => TCombinedResult
   },
   queryClient?: QueryClient,
-): CreateQueriesResult<T> {
+): Readable<TCombinedResult> {
   const client = useQueryClient(queryClient)
   // const isRestoring = useIsRestoring()
 
   const queriesStore = isWritable(queries) ? queries : writable(queries)
 
   const defaultedQueriesStore = derived(queriesStore, ($queries) => {
-    return $queries.map((options) => {
-      const defaultedOptions = client.defaultQueryOptions(options)
+    return $queries.map((opts) => {
+      const defaultedOptions = client.defaultQueryOptions(opts)
       // Make sure the results are already in fetching state before subscribing or updating options
       defaultedOptions._optimisticResults = 'optimistic'
 
       return defaultedOptions
     })
   })
-  const observer = new QueriesObserver(client, get(defaultedQueriesStore))
+  const observer = new QueriesObserver<TCombinedResult>(
+    client,
+    get(defaultedQueriesStore),
+    options as QueriesObserverOptions<TCombinedResult>,
+  )
 
   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,
+      options as QueriesObserverOptions<TCombinedResult>,
+      { listeners: false },
+    )
   })
 
-  const { subscribe } = readable(
-    observer.getOptimisticResult(get(defaultedQueriesStore)) as any,
-    (set) => {
-      return observer.subscribe(notifyManager.batchCalls(set))
-    },
+  const [, getCombinedResult] = observer.getOptimisticResult(
+    get(defaultedQueriesStore),
   )
 
+  const { subscribe } = readable(getCombinedResult() as any, (set) => {
+    return observer.subscribe(notifyManager.batchCalls(set))
+  })
+
   return { subscribe }
 }

package/src/createQuery.ts

@@ -5,7 +5,6 @@ import type {
   DefinedCreateQueryResult,
   CreateQueryOptions,
   CreateQueryResult,
-  WritableOrVal,
 } from './types'
 
 type UndefinedInitialDataOptions<
@@ -32,9 +31,7 @@ export function createQuery<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  options: WritableOrVal<
-    UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>
-  >,
+  options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
   queryClient?: QueryClient,
 ): CreateQueryResult<TData, TError>
 
@@ -44,9 +41,7 @@ export function createQuery<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  options: WritableOrVal<
-    DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>
-  >,
+  options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
   queryClient?: QueryClient,
 ): DefinedCreateQueryResult<TData, TError>
 
@@ -56,9 +51,7 @@ export function createQuery<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  options: WritableOrVal<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>
-  >,
+  options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
   queryClient?: QueryClient,
 ) {
   return createBaseQuery(options, QueryObserver, queryClient)

package/src/types.ts

@@ -10,87 +10,91 @@ import type {
   DefinedQueryObserverResult,
   DefaultError,
 } from '@tanstack/query-core'
-import type { QueryClient } from '@tanstack/query-core'
 import type { Readable, Writable } from 'svelte/store'
 
+/** Allows a type to be either the base object or a store of that object */
 export 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<
+/** Options for createBaseQuery */
+export type CreateBaseQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> extends ContextOptions,
-    QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {}
+> = WritableOrVal<
+  QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
+>
 
-export interface CreateBaseQueryResult<TData = unknown, TError = DefaultError>
-  extends Readable<QueryObserverResult<TData, TError>> {}
+/** Result from createBaseQuery */
+export type CreateBaseQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = Readable<QueryObserverResult<TData, TError>>
 
-export interface CreateQueryOptions<
+/** Options for createQuery */
+export type CreateQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> extends CreateBaseQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryFnData,
-    TQueryKey
-  > {}
+> = CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>
 
-export interface CreateQueryResult<TData = unknown, TError = DefaultError>
-  extends CreateBaseQueryResult<TData, TError> {}
+/** Result from createQuery */
+export type CreateQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = CreateBaseQueryResult<TData, TError>
 
-export interface CreateInfiniteQueryOptions<
+/** Options for createInfiniteQuery */
+export type CreateInfiniteQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
-> extends InfiniteQueryObserverOptions<
+> = WritableOrVal<
+  InfiniteQueryObserverOptions<
     TQueryFnData,
     TError,
     TData,
     TQueryData,
     TQueryKey,
     TPageParam
-  > {}
+  >
+>
 
+/** Result from createInfiniteQuery */
 export type CreateInfiniteQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = Readable<InfiniteQueryObserverResult<TData, TError>>
 
+/** Options for createBaseQuery with initialData */
 export type DefinedCreateBaseQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = Readable<DefinedQueryObserverResult<TData, TError>>
 
+/** Options for createQuery with initialData */
 export type DefinedCreateQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = DefinedCreateBaseQueryResult<TData, TError>
 
-export interface CreateMutationOptions<
+/** Options for createMutation */
+export type CreateMutationOptions<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
   TContext = unknown,
-> extends ContextOptions,
-    Omit<
-      MutationObserverOptions<TData, TError, TVariables, TContext>,
-      '_defaulted' | 'variables'
-    > {}
+> = WritableOrVal<
+  Omit<
+    MutationObserverOptions<TData, TError, TVariables, TContext>,
+    '_defaulted' | 'variables'
+  >
+>
 
 export type CreateMutateFunction<
   TData = unknown,
@@ -120,13 +124,12 @@ export type CreateBaseMutationResult<
   mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>
 }
 
-export interface CreateMutationResult<
+/** Result from createMutation */
+export type CreateMutationResult<
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
   TContext = unknown,
-> extends Readable<
-    CreateBaseMutationResult<TData, TError, TVariables, TContext>
-  > {}
+> = Readable<CreateBaseMutationResult<TData, TError, TVariables, TContext>>
 
 type Override<A, B> = { [K in keyof A]: K extends keyof B ? B[K] : A[K] }

package/build/lib/.gitignore

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

package/build/lib/createBaseQuery.d.ts

@@ -1,3 +0,0 @@
-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/createInfiniteQuery.d.ts

@@ -1,3 +0,0 @@
-import type { QueryKey, QueryClient, DefaultError, InfiniteData } from '@tanstack/query-core';
-import type { CreateInfiniteQueryOptions, CreateInfiniteQueryResult, WritableOrVal } from './types';
-export declare function createInfiniteQuery<TQueryFnData, TError = DefaultError, 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/createMutation.d.ts

@@ -1,3 +0,0 @@
-import type { QueryClient, DefaultError } from '@tanstack/query-core';
-import type { CreateMutationOptions, CreateMutationResult, WritableOrVal } from './types';
-export declare function createMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: WritableOrVal<CreateMutationOptions<TData, TError, TVariables, TContext>>, queryClient?: QueryClient): CreateMutationResult<TData, TError, TVariables, TContext>;

package/build/lib/createQueries.d.ts

@@ -1,52 +0,0 @@
-import type { QueryKey, QueryFunction, QueryClient, QueriesPlaceholderDataFunction, QueryObserverResult, DefaultError } from '@tanstack/query-core';
-import { type Readable } from 'svelte/store';
-import type { CreateQueryOptions, WritableOrVal } from './types';
-declare type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, 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;
-    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, Error, TData, TQueryKey> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TQueryFnData, TQueryKey> : CreateQueryOptionsForCreateQueries;
-declare type GetResults<T> = T extends {
-    queryFnData: any;
-    error?: infer TError;
-    data: infer TData;
-} ? QueryObserverResult<TData, TError> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? QueryObserverResult<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? QueryObserverResult<TData, TError> : T extends [any, infer TError, infer TData] ? QueryObserverResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? QueryObserverResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? QueryObserverResult<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<unknown, any>;
-    select: (data: any) => infer TData;
-} ? QueryObserverResult<TData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, any>;
-} ? QueryObserverResult<TQueryFnData> : QueryObserverResult;
-/**
- * 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 ? 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 ? DefaultError : TError>[] : QueryObserverResult[];
-export declare type CreateQueriesResult<T extends any[]> = Readable<QueriesResults<T>>;
-export declare function createQueries<T extends any[]>({ queries, }: {
-    queries: WritableOrVal<[...QueriesOptions<T>]>;
-}, queryClient?: QueryClient): CreateQueriesResult<T>;
-export {};

package/build/lib/createQuery.d.ts

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

package/build/lib/types.d.ts

@@ -1,38 +0,0 @@
-import type { InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutationObserverResult, QueryObserverOptions, QueryObserverResult, QueryKey, MutationObserverOptions, MutateFunction, DefinedQueryObserverResult, DefaultError } from '@tanstack/query-core';
-import type { QueryClient } from '@tanstack/query-core';
-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 = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends ContextOptions, QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
-}
-export interface CreateBaseQueryResult<TData = unknown, TError = DefaultError> extends Readable<QueryObserverResult<TData, TError>> {
-}
-export interface CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
-}
-export interface CreateQueryResult<TData = unknown, TError = DefaultError> extends CreateBaseQueryResult<TData, TError> {
-}
-export interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, 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 = DefaultError> = Readable<InfiniteQueryObserverResult<TData, TError>>;
-export declare type DefinedCreateBaseQueryResult<TData = unknown, TError = DefaultError> = Readable<DefinedQueryObserverResult<TData, TError>>;
-export declare type DefinedCreateQueryResult<TData = unknown, TError = DefaultError> = DefinedCreateBaseQueryResult<TData, TError>;
-export interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends ContextOptions, Omit<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted' | 'variables'> {
-}
-export declare type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
-export declare type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
-export declare type CreateBaseMutationResult<TData = unknown, TError = DefaultError, 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 = DefaultError, 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];
-};
-export {};

package/src/__tests__/CreateMutation.svelte

@@ -1,17 +0,0 @@
-<script lang="ts">
-  import {
-    createMutation,
-    QueryClient,
-    type CreateMutationOptions,
-  } from '../index'
-  import { setQueryClientContext } from '../context'
-
-  export let options: CreateMutationOptions
-
-  const queryClient = new QueryClient()
-  setQueryClientContext(queryClient)
-
-  const mutation = createMutation(options)
-</script>
-
-<button on:click={() => $mutation.mutate()}>Click</button>

package/src/__tests__/CreateQueries.svelte

@@ -1,20 +0,0 @@
-<script lang="ts">
-  import { createQueries, QueryClient } from '../index'
-  import { setQueryClientContext } from '../context'
-  import type { QueriesOptions } from '../createQueries'
-
-  export let options: { queries: [...QueriesOptions<any>] }
-
-  const queryClient = new QueryClient()
-  setQueryClientContext(queryClient)
-
-  const queries = createQueries(options)
-</script>
-
-{#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,30 +0,0 @@
-<script lang="ts">
-  import {
-    createQuery,
-    QueryClient,
-    type CreateQueryOptions,
-    type WritableOrVal,
-  } from '../index'
-  import { setQueryClientContext } from '../context'
-
-  export let options: WritableOrVal<CreateQueryOptions<any>>
-
-  const queryClient = new QueryClient()
-  setQueryClientContext(queryClient)
-
-  const query = createQuery(options)
-</script>
-
-{#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>

package/src/__tests__/createMutation.test.ts

@@ -1,24 +0,0 @@
-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 mutationFn = vi.fn()
-
-    render(CreateMutation, {
-      props: {
-        options: {
-          mutationFn,
-        },
-      },
-    })
-
-    fireEvent.click(screen.getByRole('button'))
-
-    await sleep(20)
-
-    expect(mutationFn).toHaveBeenCalledTimes(1)
-  })
-})

package/src/__tests__/createQueries.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect } from 'vitest'
-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 () => {
-    const rendered = render(CreateQueries, {
-      props: {
-        options: {
-          queries: [
-            {
-              queryKey: ['key-1'],
-              queryFn: async () => {
-                await sleep(10)
-                return 'Success 1'
-              },
-            },
-            {
-              queryKey: ['key-2'],
-              queryFn: async () => {
-                await sleep(10)
-                return 'Success 2'
-              },
-            },
-          ],
-        },
-      },
-    })
-
-    await waitFor(() => {
-      expect(rendered.getByText('Loading 1')).toBeInTheDocument()
-      expect(rendered.getByText('Loading 2')).toBeInTheDocument()
-    })
-
-    await waitFor(() => {
-      expect(rendered.getByText('Success 1')).toBeInTheDocument()
-      expect(rendered.getByText('Success 2')).toBeInTheDocument()
-    })
-  })
-})