@tanstack/solid-query 5.0.0-alpha.2 → 5.0.0-alpha.21

package/build/source/__tests__/useIsMutating.test.jsx

@@ -5,6 +5,7 @@ import { createEffect, createRenderEffect, createSignal, Show } from 'solid-js';
 import { render } from 'solid-testing-library';
 import * as MutationCacheModule from '../../../query-core/src/mutationCache';
 import { setActTimeout } from './utils';
+import { vi } from 'vitest';
 describe('useIsMutating', () => {
     it('should return the number of fetching mutations', async () => {
         const isMutatings = [];
@@ -54,9 +55,7 @@ describe('useIsMutating', () => {
         const isMutatings = [];
         const queryClient = createQueryClient();
         function IsMutating() {
-            const isMutating = useIsMutating(() => ({
-                filters: { mutationKey: ['mutation1'] },
-            }));
+            const isMutating = useIsMutating(() => ({ mutationKey: ['mutation1'] }));
             createRenderEffect(() => {
                 isMutatings.push(isMutating());
             });
@@ -94,9 +93,7 @@ describe('useIsMutating', () => {
         const queryClient = createQueryClient();
         function IsMutating() {
             const isMutating = useIsMutating(() => ({
-                filters: {
-                    predicate: (mutation) => mutation.options.mutationKey?.[0] === 'mutation1',
-                },
+                predicate: (mutation) => mutation.options.mutationKey?.[0] === 'mutation1',
             }));
             createRenderEffect(() => {
                 isMutatings.push(isMutating());
@@ -130,6 +127,27 @@ describe('useIsMutating', () => {
         // Again, No unnecessary re-renders like React
         await waitFor(() => expect(isMutatings).toEqual([0, 1, 0]));
     });
+    it('should use provided custom queryClient', async () => {
+        const queryClient = createQueryClient();
+        function Page() {
+            const isMutating = useIsMutating(undefined, () => queryClient);
+            const { mutate } = createMutation(() => ({
+                mutationKey: ['mutation1'],
+                mutationFn: async () => {
+                    await sleep(10);
+                    return 'data';
+                },
+            }), () => queryClient);
+            createEffect(() => {
+                mutate();
+            });
+            return (<div>
+          <div>mutating: {isMutating}</div>
+        </div>);
+        }
+        render(() => <Page></Page>);
+        await waitFor(() => screen.findByText('mutating: 1'));
+    });
     it('should not change state if unmounted', async () => {
         // We have to mock the MutationCache to not unsubscribe
         // the listener when the component is unmounted
@@ -139,7 +157,7 @@ describe('useIsMutating', () => {
                 return () => void 0;
             }
         }
-        const MutationCacheSpy = jest
+        const MutationCacheSpy = vi
             .spyOn(MutationCacheModule, 'MutationCache')
             .mockImplementation((fn) => {
             return new MutationCacheMock(fn);
@@ -177,25 +195,4 @@ describe('useIsMutating', () => {
         await sleep(20);
         MutationCacheSpy.mockRestore();
     });
-    it('should use provided custom queryClient', async () => {
-        const queryClient = createQueryClient();
-        function Page() {
-            const isMutating = useIsMutating(() => ({ queryClient }));
-            const { mutate } = createMutation(() => ({
-                mutationKey: ['mutation1'],
-                mutationFn: async () => {
-                    await sleep(10);
-                    return 'data';
-                },
-            }), () => queryClient);
-            createEffect(() => {
-                mutate();
-            });
-            return (<div>
-          <div>mutating: {isMutating}</div>
-        </div>);
-        }
-        render(() => <Page></Page>);
-        await waitFor(() => screen.findByText('mutating: 1'));
-    });
 });

package/build/source/__tests__/utils.jsx

@@ -1,5 +1,6 @@
-import { QueryClient } from '@tanstack/query-core';
+import { QueryClient } from '../QueryClient';
 import { createEffect, createSignal, onCleanup, Show } from 'solid-js';
+import { vi } from 'vitest';
 let queryKeyCount = 0;
 export function queryKey() {
     queryKeyCount++;
@@ -20,10 +21,10 @@ export function createQueryClient(config) {
     return new QueryClient(config);
 }
 export function mockVisibilityState(value) {
-    return jest.spyOn(document, 'visibilityState', 'get').mockReturnValue(value);
+    return vi.spyOn(document, 'visibilityState', 'get').mockReturnValue(value);
 }
 export function mockNavigatorOnLine(value) {
-    return jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(value);
+    return vi.spyOn(navigator, 'onLine', 'get').mockReturnValue(value);
 }
 export function sleep(timeout) {
     return new Promise((resolve, _reject) => {

package/build/source/createBaseQuery.js

@@ -1,15 +1,26 @@
 import { hydrate } from '@tanstack/query-core';
 import { notifyManager } from '@tanstack/query-core';
 import { isServer } from 'solid-js/web';
-import { createComputed, createMemo, createResource, on, onCleanup, onMount, } from 'solid-js';
-import { createStore, unwrap } from 'solid-js/store';
+import { createComputed, createMemo, createResource, on, onCleanup, } from 'solid-js';
+import { createStore, reconcile, unwrap } from 'solid-js/store';
 import { useQueryClient } from './QueryClientProvider';
 import { shouldThrowError } from './utils';
+function reconcileFn(store, result, reconcileOption) {
+    if (reconcileOption === false)
+        return result;
+    if (typeof reconcileOption === 'function') {
+        const newData = reconcileOption(store.data, result.data);
+        return { ...result, data: newData };
+    }
+    const newData = reconcile(result.data, { key: reconcileOption })(store.data);
+    return { ...result, data: newData };
+}
 // Base Query Function that is used to create the query.
 export function createBaseQuery(options, Observer, queryClient) {
     const client = createMemo(() => useQueryClient(queryClient?.()));
     const defaultedOptions = client().defaultQueryOptions(options());
     defaultedOptions._optimisticResults = 'optimistic';
+    defaultedOptions.structuralSharing = false;
     if (isServer) {
         defaultedOptions.retry = false;
         defaultedOptions.throwErrors = true;
@@ -19,7 +30,19 @@ export function createBaseQuery(options, Observer, queryClient) {
     const createServerSubscriber = (resolve, reject) => {
         return observer.subscribe((result) => {
             notifyManager.batchCalls(() => {
-                const unwrappedResult = { ...unwrap(result) };
+                const query = observer.getCurrentQuery();
+                const { refetch, ...rest } = unwrap(result);
+                const unwrappedResult = {
+                    ...rest,
+                    // hydrate() expects a QueryState object, which is similar but not
+                    // quite the same as a QueryObserverResult object. Thus, for now, we're
+                    // copying over the missing properties from state in order to support hydration
+                    dataUpdateCount: query.state.dataUpdateCount,
+                    fetchFailureCount: query.state.fetchFailureCount,
+                    fetchFailureReason: query.state.fetchFailureReason,
+                    fetchMeta: query.state.fetchMeta,
+                    isInvalidated: query.state.isInvalidated,
+                };
                 if (unwrappedResult.isError) {
                     if (process.env['NODE_ENV'] === 'development') {
                         console.error(unwrappedResult.error);
@@ -27,6 +50,8 @@ export function createBaseQuery(options, Observer, queryClient) {
                     reject(unwrappedResult.error);
                 }
                 if (unwrappedResult.isSuccess) {
+                    // Use of any here is fine
+                    // We cannot include refetch since it is not serializable
                     resolve(unwrappedResult);
                 }
             })();
@@ -35,17 +60,21 @@ export function createBaseQuery(options, Observer, queryClient) {
     const createClientSubscriber = () => {
         return observer.subscribe((result) => {
             notifyManager.batchCalls(() => {
-                const unwrappedResult = { ...unwrap(result) };
+                // @ts-expect-error - This will error because the reconcile option does not
+                // exist on the query-core QueryObserverResult type
+                const reconcileOptions = observer.options.reconcile;
                 // If the query has data we dont suspend but instead mutate the resource
                 // This could happen when placeholderData/initialData is defined
-                if (queryResource()?.data &&
-                    unwrappedResult.data &&
-                    !queryResource.loading) {
-                    setState(unwrappedResult);
+                if (queryResource()?.data && result.data && !queryResource.loading) {
+                    setState((store) => {
+                        return reconcileFn(store, result, reconcileOptions === undefined ? 'id' : reconcileOptions);
+                    });
                     mutate(state);
                 }
                 else {
-                    setState(unwrappedResult);
+                    setState((store) => {
+                        return reconcileFn(store, result, reconcileOptions === undefined ? 'id' : reconcileOptions);
+                    });
                     refetch();
                 }
             })();
@@ -119,12 +148,11 @@ export function createBaseQuery(options, Observer, queryClient) {
             unsubscribe = null;
         }
     });
-    onMount(() => {
-        observer.setOptions(defaultedOptions, { listeners: false });
-    });
-    createComputed(() => {
-        observer.setOptions(client().defaultQueryOptions(options()));
-    });
+    createComputed(on(() => client().defaultQueryOptions(options()), () => observer.setOptions(client().defaultQueryOptions(options())), {
+        // Defer because we don't need to trigger on first render
+        // This only cares about changes to options after the observer is created
+        defer: true,
+    }));
     createComputed(on(() => state.status, () => {
         if (state.isError &&
             !state.isFetching &&
@@ -137,10 +165,8 @@ export function createBaseQuery(options, Observer, queryClient) {
     }));
     const handler = {
         get(target, prop) {
-            if (prop === 'data') {
-                return queryResource()?.data;
-            }
-            return Reflect.get(target, prop);
+            const val = queryResource()?.[prop];
+            return val !== undefined ? val : Reflect.get(target, prop);
         },
     };
     return new Proxy(state, handler);

package/build/source/createQueries.js

@@ -2,14 +2,14 @@ import { notifyManager, QueriesObserver } from '@tanstack/query-core';
 import { createComputed, onCleanup, onMount } from 'solid-js';
 import { createStore, unwrap } from 'solid-js/store';
 import { useQueryClient } from './QueryClientProvider';
-export function createQueries(queriesOptions) {
-    const queryClient = useQueryClient(queriesOptions().queryClient);
+export function createQueries(queriesOptions, queryClient) {
+    const client = useQueryClient(queryClient?.());
     const defaultedQueries = queriesOptions().queries.map((options) => {
-        const defaultedOptions = queryClient.defaultQueryOptions(options);
+        const defaultedOptions = client.defaultQueryOptions(options);
         defaultedOptions._optimisticResults = 'optimistic';
         return defaultedOptions;
     });
-    const observer = new QueriesObserver(queryClient, defaultedQueries);
+    const observer = new QueriesObserver(client, defaultedQueries);
     const [state, setState] = createStore(observer.getOptimisticResult(defaultedQueries));
     const unsubscribe = observer.subscribe((result) => {
         notifyManager.batchCalls(() => {
@@ -22,7 +22,7 @@ export function createQueries(queriesOptions) {
     });
     createComputed(() => {
         const updatedQueries = queriesOptions().queries.map((options) => {
-            const defaultedOptions = queryClient.defaultQueryOptions(options);
+            const defaultedOptions = client.defaultQueryOptions(options);
             defaultedOptions._optimisticResults = 'optimistic';
             return defaultedOptions;
         });

package/build/source/index.js

@@ -5,6 +5,7 @@ import './setBatchUpdatesFn';
 export * from '@tanstack/query-core';
 // Solid Query
 export * from './types';
+export { QueryClient } from './QueryClient';
 export { createQuery } from './createQuery';
 export { QueryClientContext, QueryClientProvider, useQueryClient, } from './QueryClientProvider';
 export { useIsFetching } from './useIsFetching';

package/build/source/useIsFetching.js

@@ -1,11 +1,11 @@
 import { createMemo, createSignal, onCleanup } from 'solid-js';
 import { useQueryClient } from './QueryClientProvider';
-export function useIsFetching(options = () => ({})) {
-    const queryClient = createMemo(() => useQueryClient(options().queryClient));
-    const queryCache = createMemo(() => queryClient().getQueryCache());
-    const [fetches, setFetches] = createSignal(queryClient().isFetching(options().filters));
+export function useIsFetching(filters, queryClient) {
+    const client = createMemo(() => useQueryClient(queryClient?.()));
+    const queryCache = createMemo(() => client().getQueryCache());
+    const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
     const unsubscribe = queryCache().subscribe(() => {
-        setFetches(queryClient().isFetching(options().filters));
+        setFetches(client().isFetching(filters?.()));
     });
     onCleanup(unsubscribe);
     return fetches;

package/build/source/useIsMutating.js

@@ -1,11 +1,11 @@
 import { useQueryClient } from './QueryClientProvider';
 import { createSignal, onCleanup, createMemo } from 'solid-js';
-export function useIsMutating(options = () => ({})) {
-    const queryClient = createMemo(() => useQueryClient(options().queryClient));
-    const mutationCache = createMemo(() => queryClient().getMutationCache());
-    const [mutations, setMutations] = createSignal(queryClient().isMutating(options().filters));
+export function useIsMutating(filters, queryClient) {
+    const client = createMemo(() => useQueryClient(queryClient?.()));
+    const mutationCache = createMemo(() => client().getMutationCache());
+    const [mutations, setMutations] = createSignal(client().isMutating(filters?.()));
     const unsubscribe = mutationCache().subscribe((_result) => {
-        setMutations(queryClient().isMutating(options().filters));
+        setMutations(client().isMutating(filters?.()));
     });
     onCleanup(unsubscribe);
     return mutations;

package/build/types/QueryClient.d.ts

@@ -0,0 +1,29 @@
+import type { QueryClientConfig as QueryCoreClientConfig, DefaultOptions as CoreDefaultOptions, QueryObserverOptions as QueryCoreObserverOptions, InfiniteQueryObserverOptions as QueryCoreInfiniteQueryObserverOptions, DefaultError, QueryKey } from '@tanstack/query-core';
+import { QueryClient as QueryCoreClient } from '@tanstack/query-core';
+export interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends Omit<QueryCoreObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation key to `id`.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+export interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends Omit<QueryCoreInfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation key to `id`.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+export interface DefaultOptions<TError = DefaultError> extends CoreDefaultOptions<TError> {
+    queries?: QueryObserverOptions<unknown, TError>;
+}
+export interface QueryClientConfig extends QueryCoreClientConfig {
+    defaultOptions?: DefaultOptions;
+}
+export declare class QueryClient extends QueryCoreClient {
+    constructor(config?: QueryClientConfig);
+}

package/build/types/QueryClientProvider.d.ts

@@ -1,4 +1,4 @@
-import type { QueryClient } from '@tanstack/query-core';
+import type { QueryClient } from './QueryClient';
 import type { JSX } from 'solid-js';
 export declare const QueryClientContext: import("solid-js").Context<QueryClient | undefined>;
 export declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;

package/build/types/__tests__/utils.d.ts

@@ -1,15 +1,14 @@
-/// <reference types="jest" />
 /// <reference types="node" />
 import type { QueryClientConfig } from '@tanstack/query-core';
-import { QueryClient } from '@tanstack/query-core';
+import { QueryClient } from '../QueryClient';
 import type { ParentProps } from 'solid-js';
 export declare function queryKey(): Array<string>;
 export declare const Blink: (props: {
     duration: number;
 } & ParentProps) => import("solid-js").JSX.Element;
 export declare function createQueryClient(config?: QueryClientConfig): QueryClient;
-export declare function mockVisibilityState(value: DocumentVisibilityState): jest.SpyInstance<DocumentVisibilityState, [], any>;
-export declare function mockNavigatorOnLine(value: boolean): jest.SpyInstance<boolean, [], any>;
+export declare function mockVisibilityState(value: DocumentVisibilityState): import("vitest/dist/index-1cfc7f58").S<[], DocumentVisibilityState>;
+export declare function mockNavigatorOnLine(value: boolean): import("vitest/dist/index-1cfc7f58").S<[], boolean>;
 export declare function sleep(timeout: number): Promise<void>;
 export declare function setActTimeout(fn: () => void, ms?: number): NodeJS.Timeout;
 /**

package/build/types/createBaseQuery.d.ts

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

package/build/types/createInfiniteQuery.d.ts

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

package/build/types/createMutation.d.ts

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

package/build/types/createQueries.d.ts

@@ -1,4 +1,6 @@
-import type { QueriesPlaceholderDataFunction, QueryClient, QueryFunction, QueryKey, DefaultError } from '@tanstack/query-core';
+import type { QueriesPlaceholderDataFunction, QueryFunction, QueryKey, DefaultError } from '@tanstack/query-core';
+import type { QueryClient } from './QueryClient';
+import type { Accessor } from 'solid-js';
 import type { CreateQueryResult, SolidQueryOptions } from './types';
 declare type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData'> & {
     placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
@@ -44,8 +46,7 @@ export declare type QueriesOptions<T extends any[], Result extends any[] = [], D
  * QueriesResults reducer recursively maps type param to results
  */
 export declare type QueriesResults<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? 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, unknown extends TError ? DefaultError : TError>[] : CreateQueryResult[];
-export declare function createQueries<T extends any[]>(queriesOptions: () => {
+export declare function createQueries<T extends any[]>(queriesOptions: Accessor<{
     queries: readonly [...QueriesOptions<T>];
-    queryClient?: QueryClient;
-}): QueriesResults<T>;
+}>, queryClient?: Accessor<QueryClient>): QueriesResults<T>;
 export {};

package/build/types/createQuery.d.ts

@@ -1,4 +1,5 @@
-import type { QueryClient, QueryKey, DefaultError } from '@tanstack/query-core';
+import type { QueryKey, DefaultError } from '@tanstack/query-core';
+import type { QueryClient } from './QueryClient';
 import type { CreateQueryResult, DefinedCreateQueryResult, FunctionedParams, SolidQueryOptions } from './types';
 declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
     initialData?: undefined;

package/build/types/index.d.ts

@@ -1,6 +1,8 @@
 import './setBatchUpdatesFn';
 export * from '@tanstack/query-core';
 export * from './types';
+export { QueryClient } from './QueryClient';
+export type { QueryObserverOptions, DefaultOptions, QueryClientConfig, InfiniteQueryObserverOptions, } from './QueryClient';
 export { createQuery } from './createQuery';
 export { QueryClientContext, QueryClientProvider, useQueryClient, } from './QueryClientProvider';
 export type { QueryClientProviderProps } from './QueryClientProvider';

package/build/types/types.d.ts

@@ -1,4 +1,5 @@
-import type { QueryKey, QueryObserverOptions, QueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, WithRequired, DefaultError } from '@tanstack/query-core';
+import type { QueryKey, QueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverResult, WithRequired, DefaultError } from '@tanstack/query-core';
+import type { QueryObserverOptions, InfiniteQueryObserverOptions } from './QueryClient';
 export declare type FunctionedParams<T> = () => T;
 export interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'queryKey'> {
     deferStream?: boolean;

package/build/types/useIsFetching.d.ts

@@ -1,8 +1,4 @@
-import type { QueryClient, QueryFilters } from '@tanstack/query-core';
+import type { QueryFilters } from '@tanstack/query-core';
+import type { QueryClient } from './QueryClient';
 import type { Accessor } from 'solid-js';
-declare type Options = () => {
-    filters?: QueryFilters;
-    queryClient?: QueryClient;
-};
-export declare function useIsFetching(options?: Options): Accessor<number>;
-export {};
+export declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;

package/build/types/useIsMutating.d.ts

@@ -1,8 +1,4 @@
-import type { MutationFilters, QueryClient } from '@tanstack/query-core';
+import type { MutationFilters } from '@tanstack/query-core';
+import type { QueryClient } from './QueryClient';
 import type { Accessor } from 'solid-js';
-declare type Options = () => {
-    filters?: MutationFilters;
-    queryClient?: QueryClient;
-};
-export declare function useIsMutating(options?: Options): Accessor<number>;
-export {};
+export declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;

package/build/umd/index.js

@@ -1,2 +1,2 @@
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("@tanstack/query-core"),require("solid-js"),require("solid-js/web"),require("solid-js/store")):"function"==typeof define&&define.amd?define(["exports","@tanstack/query-core","solid-js","solid-js/web","solid-js/store"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).index={},e.QueryCore,e.Solid,e.SolidWeb,e.SolidStore)}(this,(function(e,t,r,n,i){"use strict";t.notifyManager.setBatchNotifyFunction(r.batch);const o=r.createContext(void 0),s=e=>{const t=r.useContext(o);if(e)return e;if(!t)throw new Error("No QueryClient set, use QueryClientProvider to set one");return t};function u(e,t){return"function"==typeof e?e(...t):!!e}function a(e,o,a){const c=r.createMemo((()=>s(a?.()))),l=c().defaultQueryOptions(e());l._optimisticResults="optimistic",n.isServer&&(l.retry=!1,l.throwErrors=!0);const f=new o(c(),l),[d,p]=i.createStore(f.getOptimisticResult(l)),y=()=>f.subscribe((e=>{t.notifyManager.batchCalls((()=>{const t={...i.unwrap(e)};C()?.data&&t.data&&!C.loading?(p(t),h(d)):(p(t),g())}))()}));let m=null;const[C,{refetch:g,mutate:h}]=r.createResource((()=>new Promise(((e,r)=>{n.isServer?m=((e,r)=>f.subscribe((n=>{t.notifyManager.batchCalls((()=>{const t={...i.unwrap(n)};t.isError&&("development"===process.env.NODE_ENV&&console.error(t.error),r(t.error)),t.isSuccess&&e(t)}))()})))(e,r):m||(m=y()),d.isLoading||e(d)}))),{initialValue:d,ssrLoadFrom:e().initialData?"initial":"server",get deferStream(){return e().deferStream},onHydrated(e,r){if(r.value&&t.hydrate(c(),{queries:[{queryKey:l.queryKey,queryHash:l.queryHash,state:r.value}]}),!m){const e={...l};!l.staleTime&&l.initialData||(e.refetchOnMount=!1),f.setOptions(e),p(f.getOptimisticResult(e)),m=y()}}});r.onCleanup((()=>{m&&(m(),m=null)})),r.onMount((()=>{f.setOptions(l,{listeners:!1})})),r.createComputed((()=>{f.setOptions(c().defaultQueryOptions(e()))})),r.createComputed(r.on((()=>d.status),(()=>{if(d.isError&&!d.isFetching&&u(f.options.throwErrors,[d.error,f.getCurrentQuery()]))throw d.error})));return new Proxy(d,{get:(e,t)=>"data"===t?C()?.data:Reflect.get(e,t)})}function c(){}e.QueryClientContext=o,e.QueryClientProvider=e=>(r.onMount((()=>{e.client.mount()})),r.onCleanup((()=>e.client.unmount())),n.createComponent(o.Provider,{get value(){return e.client},get children(){return e.children}})),e.createInfiniteQuery=function(e,n){return a(r.createMemo((()=>e())),t.InfiniteQueryObserver,n)},e.createMutation=function(e,n){const o=s(n?.()),a=new t.MutationObserver(o,e()),l=(e,t)=>{a.mutate(e,t).catch(c)},[f,d]=i.createStore({...a.getCurrentResult(),mutate:l,mutateAsync:a.getCurrentResult().mutate});r.createComputed((()=>{a.setOptions(e())})),r.createComputed(r.on((()=>f.status),(()=>{if(f.isError&&u(a.options.throwErrors,[f.error]))throw f.error})));const p=a.subscribe((e=>{d({...e,mutate:l,mutateAsync:e.mutate})}));return r.onCleanup(p),f},e.createQueries=function(e){const n=s(e().queryClient),o=e().queries.map((e=>{const t=n.defaultQueryOptions(e);return t._optimisticResults="optimistic",t})),u=new t.QueriesObserver(n,o),[a,c]=i.createStore(u.getOptimisticResult(o)),l=u.subscribe((e=>{t.notifyManager.batchCalls((()=>{c(i.unwrap(e))}))()}));return r.onCleanup(l),r.onMount((()=>{u.setQueries(o,{listeners:!1})})),r.createComputed((()=>{const t=e().queries.map((e=>{const t=n.defaultQueryOptions(e);return t._optimisticResults="optimistic",t}));u.setQueries(t)})),a},e.createQuery=function(e,n){return a(r.createMemo((()=>e())),t.QueryObserver,n)},e.useIsFetching=function(e=(()=>({}))){const t=r.createMemo((()=>s(e().queryClient))),n=r.createMemo((()=>t().getQueryCache())),[i,o]=r.createSignal(t().isFetching(e().filters)),u=n().subscribe((()=>{o(t().isFetching(e().filters))}));return r.onCleanup(u),i},e.useIsMutating=function(e=(()=>({}))){const t=r.createMemo((()=>s(e().queryClient))),n=r.createMemo((()=>t().getMutationCache())),[i,o]=r.createSignal(t().isMutating(e().filters)),u=n().subscribe((r=>{o(t().isMutating(e().filters))}));return r.onCleanup(u),i},e.useQueryClient=s,Object.keys(t).forEach((function(r){"default"===r||e.hasOwnProperty(r)||Object.defineProperty(e,r,{enumerable:!0,get:function(){return t[r]}})}))}));
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("@tanstack/query-core"),require("solid-js"),require("solid-js/web"),require("solid-js/store")):"function"==typeof define&&define.amd?define(["exports","@tanstack/query-core","solid-js","solid-js/web","solid-js/store"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).index={},e.QueryCore,e.Solid,e.SolidWeb,e.SolidStore)}(this,(function(e,t,r,n,o){"use strict";t.notifyManager.setBatchNotifyFunction(r.batch);class i extends t.QueryClient{constructor(e={}){super(e)}}const s=r.createContext(void 0),u=e=>{const t=r.useContext(s);if(e)return e;if(!t)throw new Error("No QueryClient set, use QueryClientProvider to set one");return t};function a(e,t){return"function"==typeof e?e(...t):!!e}function c(e,t,r){if(!1===r)return t;if("function"==typeof r){const n=r(e.data,t.data);return{...t,data:n}}const n=o.reconcile(t.data,{key:r})(e.data);return{...t,data:n}}function l(e,i,s){const l=r.createMemo((()=>u(s?.()))),d=l().defaultQueryOptions(e());d._optimisticResults="optimistic",d.structuralSharing=!1,n.isServer&&(d.retry=!1,d.throwErrors=!0);const f=new i(l(),d),[p,y]=o.createStore(f.getOptimisticResult(d)),m=()=>f.subscribe((e=>{t.notifyManager.batchCalls((()=>{const t=f.options.reconcile;C()?.data&&e.data&&!C.loading?(y((r=>c(r,e,void 0===t?"id":t))),b(p)):(y((r=>c(r,e,void 0===t?"id":t))),g())}))()}));let h=null;const[C,{refetch:g,mutate:b}]=r.createResource((()=>new Promise(((e,r)=>{n.isServer?h=((e,r)=>f.subscribe((n=>{t.notifyManager.batchCalls((()=>{const t=f.getCurrentQuery(),{refetch:i,...s}=o.unwrap(n),u={...s,dataUpdateCount:t.state.dataUpdateCount,fetchFailureCount:t.state.fetchFailureCount,fetchFailureReason:t.state.fetchFailureReason,fetchMeta:t.state.fetchMeta,isInvalidated:t.state.isInvalidated};u.isError&&("development"===process.env.NODE_ENV&&console.error(u.error),r(u.error)),u.isSuccess&&e(u)}))()})))(e,r):h||(h=m()),p.isLoading||e(p)}))),{initialValue:p,ssrLoadFrom:e().initialData?"initial":"server",get deferStream(){return e().deferStream},onHydrated(e,r){if(r.value&&t.hydrate(l(),{queries:[{queryKey:d.queryKey,queryHash:d.queryHash,state:r.value}]}),!h){const e={...d};!d.staleTime&&d.initialData||(e.refetchOnMount=!1),f.setOptions(e),y(f.getOptimisticResult(e)),h=m()}}});r.onCleanup((()=>{h&&(h(),h=null)})),r.createComputed(r.on((()=>l().defaultQueryOptions(e())),(()=>f.setOptions(l().defaultQueryOptions(e()))),{defer:!0})),r.createComputed(r.on((()=>p.status),(()=>{if(p.isError&&!p.isFetching&&a(f.options.throwErrors,[p.error,f.getCurrentQuery()]))throw p.error})));return new Proxy(p,{get(e,t){const r=C()?.[t];return void 0!==r?r:Reflect.get(e,t)}})}function d(){}e.QueryClient=i,e.QueryClientContext=s,e.QueryClientProvider=e=>(r.onMount((()=>{e.client.mount()})),r.onCleanup((()=>e.client.unmount())),n.createComponent(s.Provider,{get value(){return e.client},get children(){return e.children}})),e.createInfiniteQuery=function(e,n){return l(r.createMemo((()=>e())),t.InfiniteQueryObserver,n)},e.createMutation=function(e,n){const i=u(n?.()),s=new t.MutationObserver(i,e()),c=(e,t)=>{s.mutate(e,t).catch(d)},[l,f]=o.createStore({...s.getCurrentResult(),mutate:c,mutateAsync:s.getCurrentResult().mutate});r.createComputed((()=>{s.setOptions(e())})),r.createComputed(r.on((()=>l.status),(()=>{if(l.isError&&a(s.options.throwErrors,[l.error]))throw l.error})));const p=s.subscribe((e=>{f({...e,mutate:c,mutateAsync:e.mutate})}));return r.onCleanup(p),l},e.createQueries=function(e,n){const i=u(n?.()),s=e().queries.map((e=>{const t=i.defaultQueryOptions(e);return t._optimisticResults="optimistic",t})),a=new t.QueriesObserver(i,s),[c,l]=o.createStore(a.getOptimisticResult(s)),d=a.subscribe((e=>{t.notifyManager.batchCalls((()=>{l(o.unwrap(e))}))()}));return r.onCleanup(d),r.onMount((()=>{a.setQueries(s,{listeners:!1})})),r.createComputed((()=>{const t=e().queries.map((e=>{const t=i.defaultQueryOptions(e);return t._optimisticResults="optimistic",t}));a.setQueries(t)})),c},e.createQuery=function(e,n){return l(r.createMemo((()=>e())),t.QueryObserver,n)},e.useIsFetching=function(e,t){const n=r.createMemo((()=>u(t?.()))),o=r.createMemo((()=>n().getQueryCache())),[i,s]=r.createSignal(n().isFetching(e?.())),a=o().subscribe((()=>{s(n().isFetching(e?.()))}));return r.onCleanup(a),i},e.useIsMutating=function(e,t){const n=r.createMemo((()=>u(t?.()))),o=r.createMemo((()=>n().getMutationCache())),[i,s]=r.createSignal(n().isMutating(e?.())),a=o().subscribe((t=>{s(n().isMutating(e?.()))}));return r.onCleanup(a),i},e.useQueryClient=u,Object.keys(t).forEach((function(r){"default"===r||e.hasOwnProperty(r)||Object.defineProperty(e,r,{enumerable:!0,get:function(){return t[r]}})}))}));
 //# sourceMappingURL=index.js.map