@tanstack/svelte-query 5.0.0-alpha.32 → 5.0.0-alpha.37

package/build/lib/__tests__/CreateQuery.svelte.d.ts

@@ -1,8 +1,8 @@
 import { SvelteComponentTyped } from "svelte";
-import type { CreateQueryOptions, WritableOrVal } from '../types';
+import type { CreateQueryOptions } from '../types';
 declare const __propDef: {
     props: {
-        options: WritableOrVal<CreateQueryOptions<any>>;
+        options: CreateQueryOptions<any>;
     };
     events: {
         [evt: string]: CustomEvent<any>;

package/build/lib/createBaseQuery.d.ts

@@ -1,3 +1,3 @@
 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>;
+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, queryClient?: QueryClient): CreateBaseQueryResult<TData, TError>;

package/build/lib/createInfiniteQuery.d.ts

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

package/build/lib/createMutation.d.ts

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

package/build/lib/createQueries.d.ts

@@ -1,7 +1,7 @@
-import type { QueryKey, QueryFunction, QueryClient, QueriesPlaceholderDataFunction, QueryObserverResult, DefaultError } from '@tanstack/query-core';
+import type { QueryKey, QueryFunction, QueryClient, QueriesPlaceholderDataFunction, QueryObserverResult, DefaultError, QueryObserverOptions } 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'> & {
+import type { WritableOrVal } from './types';
+declare type QueryObserverOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'placeholderData'> & {
     placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
 };
 declare type MAXIMUM_DEPTH = 20;
@@ -9,18 +9,18 @@ declare type GetOptions<T> = T extends {
     queryFnData: infer TQueryFnData;
     error?: infer TError;
     data: infer TData;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
+} ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
     queryFnData: infer TQueryFnData;
     error?: infer TError;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends {
+} ? QueryObserverOptionsForCreateQueries<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 {
+} ? QueryObserverOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? QueryObserverOptionsForCreateQueries<TQueryFnData> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
     select: (data: any) => infer TData;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TData, TQueryKey> : T extends {
+} ? QueryObserverOptionsForCreateQueries<TQueryFnData, Error, TData, TQueryKey> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TQueryFnData, TQueryKey> : CreateQueryOptionsForCreateQueries;
+} ? QueryObserverOptionsForCreateQueries<TQueryFnData, Error, TQueryFnData, TQueryKey> : QueryObserverOptionsForCreateQueries;
 declare type GetResults<T> = T extends {
     queryFnData: any;
     error?: infer TError;
@@ -40,13 +40,13 @@ declare type GetResults<T> = T extends {
 /**
  * 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[];
+export declare type QueriesOptions<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? QueryObserverOptionsForCreateQueries[] : 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 QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>[] ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>[] : QueryObserverOptionsForCreateQueries[];
 /**
  * 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, }: {
+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 QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, any>[] ? QueryObserverResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError>[] : QueryObserverResult[];
+export declare function createQueries<T extends any[], TCombinedResult = QueriesResults<T>>({ queries, ...options }: {
     queries: WritableOrVal<[...QueriesOptions<T>]>;
-}, queryClient?: QueryClient): CreateQueriesResult<T>;
+    combine?: (result: QueriesResults<T>) => TCombinedResult;
+}, queryClient?: QueryClient): Readable<TCombinedResult>;
 export {};

package/build/lib/createQueries.js

@@ -2,25 +2,26 @@ import { notifyManager, QueriesObserver } from '@tanstack/query-core';
 import { derived, get, readable, writable } from 'svelte/store';
 import { useQueryClient } from './useQueryClient';
 import { isWritable } from './utils';
-export function createQueries({ queries, }, queryClient) {
+export function createQueries({ queries, ...options }, queryClient) {
     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(client, get(defaultedQueriesStore), options);
     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, { listeners: false });
     });
-    const { subscribe } = readable(observer.getOptimisticResult(get(defaultedQueriesStore)), (set) => {
+    const [, getCombinedResult] = observer.getOptimisticResult(get(defaultedQueriesStore));
+    const { subscribe } = readable(getCombinedResult(), (set) => {
         return observer.subscribe(notifyManager.batchCalls(set));
     });
     return { subscribe };

package/build/lib/createQuery.d.ts

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

package/build/lib/types.d.ts

@@ -1,28 +1,25 @@
 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';
+/** Allows a type to be either the base object or a store of that object */
 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> {
-}
+/** Options for createBaseQuery */
+export declare type CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WritableOrVal<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>;
+/** Result from createBaseQuery */
+export declare type CreateBaseQueryResult<TData = unknown, TError = DefaultError> = Readable<QueryObserverResult<TData, TError>>;
+/** Options for createQuery */
+export declare type CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>;
+/** Result from createQuery */
+export declare type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
+/** Options for createInfiniteQuery */
+export declare type CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = WritableOrVal<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>>;
+/** Result from createInfiniteQuery */
 export declare type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = Readable<InfiniteQueryObserverResult<TData, TError>>;
+/** Options for createBaseQuery with initialData */
 export declare type DefinedCreateBaseQueryResult<TData = unknown, TError = DefaultError> = Readable<DefinedQueryObserverResult<TData, TError>>;
+/** Options for createQuery with initialData */
 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'> {
-}
+/** Options for createMutation */
+export declare type CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = WritableOrVal<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>, {
@@ -30,8 +27,8 @@ export declare type CreateBaseMutationResult<TData = unknown, TError = DefaultEr
 }> & {
     mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>;
 };
-export interface CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> extends Readable<CreateBaseMutationResult<TData, TError, TVariables, TContext>> {
-}
+/** Result from createMutation */
+export declare type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Readable<CreateBaseMutationResult<TData, TError, TVariables, TContext>>;
 declare type Override<A, B> = {
     [K in keyof A]: K extends keyof B ? B[K] : A[K];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/svelte-query",
-  "version": "5.0.0-alpha.32",
+  "version": "5.0.0-alpha.37",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Svelte",
   "author": "Lachlan Collins",
   "license": "MIT",
@@ -42,7 +42,7 @@
     "vite": "^4.0.0"
   },
   "dependencies": {
-    "@tanstack/query-core": "5.0.0-alpha.32"
+    "@tanstack/query-core": "5.0.0-alpha.34"
   },
   "peerDependencies": {
     "svelte": "^3.54.0"

package/src/createBaseQuery.ts

@@ -1,10 +1,6 @@
 import type { QueryClient, QueryKey, QueryObserver } from '@tanstack/query-core'
 import { notifyManager } from '@tanstack/query-core'
-import type {
-  CreateBaseQueryOptions,
-  CreateBaseQueryResult,
-  WritableOrVal,
-} from './types'
+import type { CreateBaseQueryOptions, CreateBaseQueryResult } from './types'
 import { useQueryClient } from './useQueryClient'
 import { derived, get, readable, writable } from 'svelte/store'
 import { isWritable } from './utils'
@@ -16,8 +12,12 @@ export function createBaseQuery<
   TQueryData,
   TQueryKey extends QueryKey,
 >(
-  options: WritableOrVal<
-    CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
+  options: CreateBaseQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryData,
+    TQueryKey
   >,
   Observer: typeof QueryObserver,
   queryClient?: QueryClient,

package/src/createInfiniteQuery.ts

@@ -9,7 +9,6 @@ import { InfiniteQueryObserver } from '@tanstack/query-core'
 import type {
   CreateInfiniteQueryOptions,
   CreateInfiniteQueryResult,
-  WritableOrVal,
 } from './types'
 import { createBaseQuery } from './createBaseQuery'
 
@@ -20,15 +19,13 @@ export function createInfiniteQuery<
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 >(
-  options: WritableOrVal<
-    CreateInfiniteQueryOptions<
-      TQueryFnData,
-      TError,
-      TData,
-      TQueryFnData,
-      TQueryKey,
-      TPageParam
-    >
+  options: CreateInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryFnData,
+    TQueryKey,
+    TPageParam
   >,
   queryClient?: QueryClient,
 ): CreateInfiniteQueryResult<TData, TError> {

package/src/createMutation.ts

@@ -5,7 +5,6 @@ import type {
   CreateMutateFunction,
   CreateMutationOptions,
   CreateMutationResult,
-  WritableOrVal,
 } from './types'
 import { useQueryClient } from './useQueryClient'
 import { isWritable } from './utils'
@@ -16,9 +15,7 @@ export function createMutation<
   TVariables = void,
   TContext = unknown,
 >(
-  options: WritableOrVal<
-    CreateMutationOptions<TData, TError, TVariables, TContext>
-  >,
+  options: CreateMutationOptions<TData, TError, TVariables, TContext>,
   queryClient?: QueryClient,
 ): CreateMutationResult<TData, TError, TVariables, TContext> {
   const client = useQueryClient(queryClient)

package/src/createQueries.ts

@@ -5,24 +5,26 @@ 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 +40,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 +107,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 +118,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 +148,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 +162,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] }