@tanstack/solid-query 5.0.0-alpha.3 → 5.0.0-alpha.5

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

@@ -3,6 +3,7 @@ import { createEffect, createRenderEffect, createSignal, ErrorBoundary, } from '
 import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
 import { createMutation, MutationCache, QueryCache, QueryClientProvider, } from '..';
 import { createQueryClient, mockNavigatorOnLine, queryKey, setActTimeout, sleep, } from './utils';
+import { vi } from 'vitest';
 describe('createMutation', () => {
     const queryCache = new QueryCache();
     const mutationCache = new MutationCache();
@@ -63,8 +64,8 @@ describe('createMutation', () => {
     });
     it('should be able to call `onSuccess` and `onSettled` after each successful mutate', async () => {
         const [count, setCount] = createSignal(0);
-        const onSuccessMock = jest.fn();
-        const onSettledMock = jest.fn();
+        const onSuccessMock = vi.fn();
+        const onSettledMock = vi.fn();
         function Page() {
             const mutation = createMutation(() => ({
                 mutationFn: (vars) => Promise.resolve(vars.count),
@@ -110,7 +111,7 @@ describe('createMutation', () => {
     });
     it('should set correct values for `failureReason` and `failureCount` on multiple mutate calls', async () => {
         const [count, setCount] = createSignal(0);
-        const mutateFn = jest.fn();
+        const mutateFn = vi.fn();
         mutateFn.mockImplementationOnce(() => {
             return Promise.reject(new Error('Error test Jonas'));
         });
@@ -152,8 +153,8 @@ describe('createMutation', () => {
         await waitFor(() => screen.getByText('Failed because null'));
     });
     it('should be able to call `onError` and `onSettled` after each failed mutate', async () => {
-        const onErrorMock = jest.fn();
-        const onSettledMock = jest.fn();
+        const onErrorMock = vi.fn();
+        const onSettledMock = vi.fn();
         const [count, setCount] = createSignal(0);
         function Page() {
             const mutation = createMutation(() => ({
@@ -388,7 +389,7 @@ describe('createMutation', () => {
     });
     it('should call onMutate even if paused', async () => {
         const onlineMock = mockNavigatorOnLine(false);
-        const onMutate = jest.fn();
+        const onMutate = vi.fn();
         let count = 0;
         function Page() {
             const mutation = createMutation(() => ({
@@ -617,8 +618,8 @@ describe('createMutation', () => {
         });
     });
     it('should pass meta to mutation', async () => {
-        const errorMock = jest.fn();
-        const successMock = jest.fn();
+        const errorMock = vi.fn();
+        const successMock = vi.fn();
         const queryClientMutationMeta = createQueryClient({
             mutationCache: new MutationCache({
                 onSuccess: (_, __, ___, mutation) => {
@@ -664,10 +665,10 @@ describe('createMutation', () => {
         expect(errorMock).toHaveBeenCalledWith(metaErrorMessage);
     });
     it('should call cache callbacks when unmounted', async () => {
-        const onSuccess = jest.fn();
-        const onSuccessMutate = jest.fn();
-        const onSettled = jest.fn();
-        const onSettledMutate = jest.fn();
+        const onSuccess = vi.fn();
+        const onSuccessMutate = vi.fn();
+        const onSettled = vi.fn();
+        const onSettledMutate = vi.fn();
         const mutationKey = queryKey();
         let count = 0;
         function Page() {
@@ -718,10 +719,10 @@ describe('createMutation', () => {
         expect(onSettledMutate).toHaveBeenCalledTimes(0);
     });
     it('should call mutate callbacks only for the last observer', async () => {
-        const onSuccess = jest.fn();
-        const onSuccessMutate = jest.fn();
-        const onSettled = jest.fn();
-        const onSettledMutate = jest.fn();
+        const onSuccess = vi.fn();
+        const onSuccessMutate = vi.fn();
+        const onSettled = vi.fn();
+        const onSettledMutate = vi.fn();
         let count = 0;
         function Page() {
             const mutation = createMutation(() => ({
@@ -762,7 +763,7 @@ describe('createMutation', () => {
     });
     it('should go to error state if onSuccess callback errors', async () => {
         const error = new Error('error from onSuccess');
-        const onError = jest.fn();
+        const onError = vi.fn();
         function Page() {
             const mutation = createMutation(() => ({
                 mutationFn: async (_text) => {
@@ -815,7 +816,7 @@ describe('createMutation', () => {
     it('should go to error state if onSettled callback errors', async () => {
         const error = new Error('error from onSettled');
         const mutateFnError = new Error('mutateFnError');
-        const onError = jest.fn();
+        const onError = vi.fn();
         function Page() {
             const mutation = createMutation(() => ({
                 mutationFn: async (_text) => {

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

@@ -3,6 +3,7 @@ import * as QueriesObserverModule from '../../../query-core/src/queriesObserver'
 import { createRenderEffect, createSignal } from 'solid-js';
 import { createQueries, QueriesObserver, QueryCache, QueryClientProvider, } from '..';
 import { createQueryClient, expectType, expectTypeNotAny, queryKey, sleep, } from './utils';
+import { vi } from 'vitest';
 describe('useQueries', () => {
     const queryCache = new QueryCache();
     const queryClient = createQueryClient({ queryCache });
@@ -620,7 +621,7 @@ describe('useQueries', () => {
                 return () => void 0;
             }
         }
-        const QueriesObserverSpy = jest
+        const QueriesObserverSpy = vi
             .spyOn(QueriesObserverModule, 'QueriesObserver')
             .mockImplementation((fn) => {
             return new QueriesObserverMock(fn);
@@ -657,21 +658,4 @@ describe('useQueries', () => {
         await sleep(20);
         QueriesObserverSpy.mockRestore();
     });
-    it('should use provided custom queryClient', async () => {
-        const key = queryKey();
-        const queryFn = () => {
-            return Promise.resolve('custom client');
-        };
-        function Page() {
-            const state = createQueries(() => ({
-                queries: [{ queryKey: key, queryFn }],
-                queryClient,
-            }));
-            return (<div>
-          <h1>Status: {state[0].data}</h1>
-        </div>);
-        }
-        render(() => <Page />);
-        await waitFor(() => screen.getByText('Status: custom client'));
-    });
 });

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

@@ -3,6 +3,7 @@ import { createEffect, createMemo, createRenderEffect, createSignal, ErrorBounda
 import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
 import { createQuery, QueryCache, QueryClientProvider, keepPreviousData, } from '..';
 import { Blink, createQueryClient, expectType, mockNavigatorOnLine, mockVisibilityState, queryKey, setActTimeout, sleep, } from './utils';
+import { vi } from 'vitest';
 describe('createQuery', () => {
     const queryCache = new QueryCache();
     const queryClient = createQueryClient({ queryCache });
@@ -361,7 +362,7 @@ describe('createQuery', () => {
     it('should call onSuccess after a query has been fetched', async () => {
         const key = queryKey();
         const states = [];
-        const onSuccess = jest.fn();
+        const onSuccess = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -387,7 +388,7 @@ describe('createQuery', () => {
     it('should call onSuccess after a disabled query has been fetched', async () => {
         const key = queryKey();
         const states = [];
-        const onSuccess = jest.fn();
+        const onSuccess = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -416,7 +417,7 @@ describe('createQuery', () => {
     it('should not call onSuccess if a component has unmounted', async () => {
         const key = queryKey();
         const states = [];
-        const onSuccess = jest.fn();
+        const onSuccess = vi.fn();
         function Page() {
             const [show, setShow] = createSignal(true);
             createEffect(() => {
@@ -448,7 +449,7 @@ describe('createQuery', () => {
     it('should call onError after a query has been fetched with an error', async () => {
         const key = queryKey();
         const states = [];
-        const onError = jest.fn();
+        const onError = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -471,7 +472,7 @@ describe('createQuery', () => {
     });
     it('should not call onError when receiving a CancelledError', async () => {
         const key = queryKey();
-        const onError = jest.fn();
+        const onError = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -497,7 +498,7 @@ describe('createQuery', () => {
     it('should call onSettled after a query has been fetched', async () => {
         const key = queryKey();
         const states = [];
-        const onSettled = jest.fn();
+        const onSettled = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -520,7 +521,7 @@ describe('createQuery', () => {
     it('should call onSettled after a query has been fetched with an error', async () => {
         const key = queryKey();
         const states = [];
-        const onSettled = jest.fn();
+        const onSettled = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -1887,7 +1888,7 @@ describe('createQuery', () => {
     });
     it('should not refetch query on focus when `enabled` is set to `false`', async () => {
         const key = queryKey();
-        const queryFn = jest.fn().mockReturnValue('data');
+        const queryFn = vi.fn().mockReturnValue('data');
         function Page() {
             const { data = 'default' } = createQuery(() => ({
                 queryKey: key,
@@ -2523,7 +2524,7 @@ describe('createQuery', () => {
     });
     it('should retry specified number of times', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => {
             return Promise.reject(new Error('Error test Barrett'));
         });
@@ -2552,7 +2553,7 @@ describe('createQuery', () => {
     });
     it('should not retry if retry function `false`', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementationOnce(() => {
             return Promise.reject(new Error('Error test Tanner'));
         });
@@ -2585,7 +2586,7 @@ describe('createQuery', () => {
     });
     it('should extract retryDelay from error', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => {
             return Promise.reject({ delay: 50 });
         });
@@ -2747,9 +2748,9 @@ describe('createQuery', () => {
     it('should refetch if stale after a prefetch', async () => {
         const key = queryKey();
         const states = [];
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => 'data');
-        const prefetchQueryFn = jest.fn();
+        const prefetchQueryFn = vi.fn();
         prefetchQueryFn.mockImplementation(() => 'not yet...');
         await queryClient.prefetchQuery({
             queryKey: key,
@@ -2773,9 +2774,9 @@ describe('createQuery', () => {
     });
     it('should not refetch if not stale after a prefetch', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => 'data');
-        const prefetchQueryFn = jest.fn();
+        const prefetchQueryFn = vi.fn();
         prefetchQueryFn.mockImplementation(async () => {
             await sleep(10);
             return 'not yet...';
@@ -2977,7 +2978,7 @@ describe('createQuery', () => {
     });
     it('it should support enabled:false in query object syntax', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => 'data');
         function Page() {
             const { fetchStatus } = createQuery(() => ({
@@ -3028,7 +3029,7 @@ describe('createQuery', () => {
         <Page />
       </QueryClientProvider>));
         await waitFor(() => screen.getByText('fetched data'));
-        const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
+        const setTimeoutSpy = vi.spyOn(window, 'setTimeout');
         result.unmount();
         expect(setTimeoutSpy).not.toHaveBeenCalled();
     });
@@ -3046,14 +3047,14 @@ describe('createQuery', () => {
         <Page />
       </QueryClientProvider>));
         await waitFor(() => screen.getByText('fetched data'));
-        const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
+        const setTimeoutSpy = vi.spyOn(window, 'setTimeout');
         result.unmount();
         expect(setTimeoutSpy).toHaveBeenLastCalledWith(expect.any(Function), 1000 * 60 * 10);
     });
     it('should not cause memo churn when data does not change', async () => {
         const key = queryKey();
-        const queryFn = jest.fn().mockReturnValue('data');
-        const memoFn = jest.fn();
+        const queryFn = vi.fn().mockReturnValue('data');
+        const memoFn = vi.fn();
         function Page() {
             const result = createQuery(() => ({
                 queryKey: key,
@@ -3234,7 +3235,7 @@ describe('createQuery', () => {
     });
     it('should refetch if any query instance becomes enabled', async () => {
         const key = queryKey();
-        const queryFn = jest.fn().mockReturnValue('data');
+        const queryFn = vi.fn().mockReturnValue('data');
         function Disabled() {
             createQuery(() => ({ queryKey: key, queryFn, enabled: false }));
             return null;
@@ -3504,10 +3505,10 @@ describe('createQuery', () => {
     });
     it('should cancel the query function when there are no more subscriptions', async () => {
         const key = queryKey();
-        let cancelFn = jest.fn();
+        let cancelFn = vi.fn();
         const queryFn = ({ signal }) => {
             const promise = new Promise((resolve, reject) => {
-                cancelFn = jest.fn(() => reject('Cancelled'));
+                cancelFn = vi.fn(() => reject('Cancelled'));
                 signal?.addEventListener('abort', cancelFn);
                 sleep(20).then(() => resolve('OK'));
             });
@@ -3767,7 +3768,7 @@ describe('createQuery', () => {
         expect(renders).toBe(hashes);
     });
     it('should refetch when changed enabled to true in error state', async () => {
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(async () => {
             await sleep(10);
             return Promise.reject(new Error('Suspense Error Bingo'));
@@ -4514,7 +4515,7 @@ describe('createQuery', () => {
     });
     it('setQueryData - should not call onSuccess callback of active observers', async () => {
         const key = queryKey();
-        const onSuccess = jest.fn();
+        const onSuccess = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,

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

@@ -2,6 +2,7 @@ import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
 import { createRenderEffect, createSignal, ErrorBoundary, on, Show, Suspense, } from 'solid-js';
 import { createInfiniteQuery, createQuery, QueryCache, QueryClientProvider, } from '..';
 import { createQueryClient, queryKey, sleep } from './utils';
+import { vi } from 'vitest';
 describe("useQuery's in Suspense mode", () => {
     const queryCache = new QueryCache();
     const queryClient = createQueryClient({ queryCache });
@@ -91,7 +92,7 @@ describe("useQuery's in Suspense mode", () => {
     });
     it('should not call the queryFn twice when used in Suspense mode', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => {
             sleep(10);
             return 'data';
@@ -141,7 +142,7 @@ describe("useQuery's in Suspense mode", () => {
     });
     it('should call onSuccess on the first successful call', async () => {
         const key = queryKey();
-        const successFn = jest.fn();
+        const successFn = vi.fn();
         function Page() {
             createQuery(() => ({
                 queryKey: [key],
@@ -166,8 +167,8 @@ describe("useQuery's in Suspense mode", () => {
     });
     it('should call every onSuccess handler within a suspense boundary', async () => {
         const key = queryKey();
-        const successFn1 = jest.fn();
-        const successFn2 = jest.fn();
+        const successFn1 = vi.fn();
+        const successFn2 = vi.fn();
         function FirstComponent() {
             createQuery(() => ({
                 queryKey: key,
@@ -514,7 +515,7 @@ describe("useQuery's in Suspense mode", () => {
     });
     it('should not call the queryFn when not enabled', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(async () => {
             await sleep(10);
             return '23';

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

@@ -120,9 +120,7 @@ describe('useIsFetching', () => {
         function Page() {
             const [started, setStarted] = createSignal(false);
             const isFetching = useIsFetching(() => ({
-                filters: {
-                    queryKey: key1,
-                },
+                queryKey: key1,
             }));
             createRenderEffect(() => {
                 isFetchings.push(isFetching());
@@ -181,7 +179,7 @@ describe('useIsFetching', () => {
                     return 'test';
                 },
             }), () => queryClient);
-            const isFetching = useIsFetching(() => ({ queryClient }));
+            const isFetching = useIsFetching(undefined, () => queryClient);
             return (<div>
           <div>isFetching: {isFetching}</div>
         </div>);

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 { 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/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/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/__tests__/utils.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="jest" />
 /// <reference types="node" />
 import type { QueryClientConfig } from '@tanstack/query-core';
 import { QueryClient } from '@tanstack/query-core';
@@ -8,8 +7,8 @@ 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,4 @@
 import type { QueryClient, QueryKey, QueryObserver, QueryObserverResult } from '@tanstack/query-core';
 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,4 @@
 import type { QueryKey, QueryClient, DefaultError, InfiniteData } from '@tanstack/query-core';
 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,4 @@
 import type { QueryClient, DefaultError } from '@tanstack/query-core';
 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,5 @@
 import type { QueriesPlaceholderDataFunction, QueryClient, QueryFunction, QueryKey, DefaultError } from '@tanstack/query-core';
+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 +45,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 {};