@tanstack/solid-query 5.0.0-alpha.7 → 5.0.0-alpha.75

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

@@ -1,42 +0,0 @@
-import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
-import { createSignal, Show, startTransition, Suspense } from 'solid-js';
-import { createQuery, QueryCache, QueryClientProvider } from '..';
-import { createQueryClient, queryKey, sleep } from './utils';
-describe("useQuery's in Suspense mode with transitions", () => {
-    const queryCache = new QueryCache();
-    const queryClient = createQueryClient({ queryCache });
-    it('should render the content when the transition is done', async () => {
-        const key = queryKey();
-        function Suspended() {
-            const state = createQuery(() => ({
-                queryKey: key,
-                queryFn: async () => {
-                    await sleep(10);
-                    return true;
-                },
-            }));
-            return <Show when={state.data}>Message</Show>;
-        }
-        function Page() {
-            const [showSignal, setShowSignal] = createSignal(false);
-            return (<div>
-          <button aria-label="toggle" onClick={() => startTransition(() => setShowSignal((value) => !value))}>
-            {showSignal() ? 'Hide' : 'Show'}
-          </button>
-          <Suspense fallback="Loading">
-            <Show when={showSignal()}>
-              <Suspended />
-            </Show>
-          </Suspense>
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await waitFor(() => screen.getByText('Show'));
-        fireEvent.click(screen.getByLabelText('toggle'));
-        await waitFor(() => screen.getByText('Message'));
-        // verify that the button also updated. See https://github.com/solidjs/solid/issues/1249
-        await waitFor(() => screen.getByText('Hide'));
-    });
-});

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

@@ -1,190 +0,0 @@
-import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
-import { createEffect, createRenderEffect, createSignal, Show } from 'solid-js';
-import { createQuery, QueryCache, QueryClientProvider, useIsFetching } from '..';
-import { createQueryClient, queryKey, setActTimeout, sleep } from './utils';
-describe('useIsFetching', () => {
-    // See https://github.com/tannerlinsley/react-query/issues/105
-    it('should update as queries start and stop fetching', async () => {
-        const queryCache = new QueryCache();
-        const queryClient = createQueryClient({ queryCache });
-        const key = queryKey();
-        function IsFetching() {
-            const isFetching = useIsFetching();
-            return <div>isFetching: {isFetching()}</div>;
-        }
-        function Query() {
-            const [ready, setReady] = createSignal(false);
-            createQuery(() => ({
-                queryKey: key,
-                queryFn: async () => {
-                    await sleep(50);
-                    return 'test';
-                },
-                enabled: ready(),
-            }));
-            return <button onClick={() => setReady(true)}>setReady</button>;
-        }
-        function Page() {
-            return (<div>
-          <IsFetching />
-          <Query />
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await screen.findByText('isFetching: 0');
-        fireEvent.click(screen.getByRole('button', { name: /setReady/i }));
-        await screen.findByText('isFetching: 1');
-        await screen.findByText('isFetching: 0');
-    });
-    it('should not update state while rendering', async () => {
-        const queryCache = new QueryCache();
-        const queryClient = createQueryClient({ queryCache });
-        const key1 = queryKey();
-        const key2 = queryKey();
-        const isFetchings = [];
-        function IsFetching() {
-            const isFetching = useIsFetching();
-            createRenderEffect(() => {
-                isFetchings.push(isFetching());
-            });
-            return null;
-        }
-        function FirstQuery() {
-            createQuery(() => ({
-                queryKey: key1,
-                queryFn: async () => {
-                    await sleep(150);
-                    return 'data';
-                },
-            }));
-            return null;
-        }
-        function SecondQuery() {
-            createQuery(() => ({
-                queryKey: key2,
-                queryFn: async () => {
-                    await sleep(200);
-                    return 'data';
-                },
-            }));
-            return null;
-        }
-        function Page() {
-            const [renderSecond, setRenderSecond] = createSignal(false);
-            createEffect(() => {
-                setActTimeout(() => {
-                    setRenderSecond(true);
-                }, 100);
-            });
-            return (<>
-          <IsFetching />
-          <FirstQuery />
-          <Show when={renderSecond()}>
-            <SecondQuery />
-          </Show>
-        </>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        // unlike react, Updating renderSecond wont cause a rerender for FirstQuery
-        await waitFor(() => expect(isFetchings).toEqual([0, 1, 2, 1, 0]));
-    });
-    it('should be able to filter', async () => {
-        const queryClient = createQueryClient();
-        const key1 = queryKey();
-        const key2 = queryKey();
-        const isFetchings = [];
-        function One() {
-            createQuery(() => ({
-                queryKey: key1,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 'test';
-                },
-            }));
-            return null;
-        }
-        function Two() {
-            createQuery(() => ({
-                queryKey: key2,
-                queryFn: async () => {
-                    await sleep(20);
-                    return 'test';
-                },
-            }));
-            return null;
-        }
-        function Page() {
-            const [started, setStarted] = createSignal(false);
-            const isFetching = useIsFetching(() => ({
-                queryKey: key1,
-            }));
-            createRenderEffect(() => {
-                isFetchings.push(isFetching());
-            });
-            return (<div>
-          <button onClick={() => setStarted(true)}>setStarted</button>
-          <div>isFetching: {isFetching()}</div>
-          <Show when={started()}>
-            <>
-              <One />
-              <Two />
-            </>
-          </Show>
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await screen.findByText('isFetching: 0');
-        fireEvent.click(screen.getByRole('button', { name: /setStarted/i }));
-        await screen.findByText('isFetching: 1');
-        await screen.findByText('isFetching: 0');
-        // at no point should we have isFetching: 2
-        expect(isFetchings).toEqual(expect.not.arrayContaining([2]));
-    });
-    it('should show the correct fetching state when mounted after a query', async () => {
-        const queryClient = createQueryClient();
-        const key = queryKey();
-        function Page() {
-            createQuery(() => ({
-                queryKey: key,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 'test';
-                },
-            }));
-            const isFetching = useIsFetching();
-            return (<div>
-          <div>isFetching: {isFetching()}</div>
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await screen.findByText('isFetching: 1');
-        await screen.findByText('isFetching: 0');
-    });
-    it('should use provided custom queryClient', async () => {
-        const queryClient = createQueryClient();
-        const key = queryKey();
-        function Page() {
-            createQuery(() => ({
-                queryKey: key,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 'test';
-                },
-            }), () => queryClient);
-            const isFetching = useIsFetching(undefined, () => queryClient);
-            return (<div>
-          <div>isFetching: {isFetching}</div>
-        </div>);
-        }
-        render(() => <Page></Page>);
-        await screen.findByText('isFetching: 1');
-    });
-});

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

@@ -1,198 +0,0 @@
-import { fireEvent, screen, waitFor } from 'solid-testing-library';
-import { createMutation, QueryClientProvider, useIsMutating } from '..';
-import { createQueryClient, sleep } from './utils';
-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 = [];
-        const queryClient = createQueryClient();
-        function IsMutating() {
-            const isMutating = useIsMutating();
-            createRenderEffect(() => {
-                isMutatings.push(isMutating());
-            });
-            return null;
-        }
-        function Mutations() {
-            const { mutate: mutate1 } = createMutation(() => ({
-                mutationKey: ['mutation1'],
-                mutationFn: async () => {
-                    await sleep(150);
-                    return 'data';
-                },
-            }));
-            const { mutate: mutate2 } = createMutation(() => ({
-                mutationKey: ['mutation2'],
-                mutationFn: async () => {
-                    await sleep(50);
-                    return 'data';
-                },
-            }));
-            createEffect(() => {
-                mutate1();
-                setActTimeout(() => {
-                    mutate2();
-                }, 50);
-            });
-            return null;
-        }
-        function Page() {
-            return (<div>
-          <IsMutating />
-          <Mutations />
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await waitFor(() => expect(isMutatings).toEqual([0, 1, 2, 1, 0]));
-    });
-    it('should filter correctly by mutationKey', async () => {
-        const isMutatings = [];
-        const queryClient = createQueryClient();
-        function IsMutating() {
-            const isMutating = useIsMutating(() => ({ mutationKey: ['mutation1'] }));
-            createRenderEffect(() => {
-                isMutatings.push(isMutating());
-            });
-            return null;
-        }
-        function Page() {
-            const { mutate: mutate1 } = createMutation(() => ({
-                mutationKey: ['mutation1'],
-                mutationFn: async () => {
-                    await sleep(100);
-                    return 'data';
-                },
-            }));
-            const { mutate: mutate2 } = createMutation(() => ({
-                mutationKey: ['mutation2'],
-                mutationFn: async () => {
-                    await sleep(100);
-                    return 'data';
-                },
-            }));
-            createEffect(() => {
-                mutate1();
-                mutate2();
-            });
-            return <IsMutating />;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        // Unlike React, IsMutating Wont re-render twice with mutation2
-        await waitFor(() => expect(isMutatings).toEqual([0, 1, 0]));
-    });
-    it('should filter correctly by predicate', async () => {
-        const isMutatings = [];
-        const queryClient = createQueryClient();
-        function IsMutating() {
-            const isMutating = useIsMutating(() => ({
-                predicate: (mutation) => mutation.options.mutationKey?.[0] === 'mutation1',
-            }));
-            createRenderEffect(() => {
-                isMutatings.push(isMutating());
-            });
-            return null;
-        }
-        function Page() {
-            const { mutate: mutate1 } = createMutation(() => ({
-                mutationKey: ['mutation1'],
-                mutationFn: async () => {
-                    await sleep(100);
-                    return 'data';
-                },
-            }));
-            const { mutate: mutate2 } = createMutation(() => ({
-                mutationKey: ['mutation2'],
-                mutationFn: async () => {
-                    await sleep(100);
-                    return 'data';
-                },
-            }));
-            createEffect(() => {
-                mutate1();
-                mutate2();
-            });
-            return <IsMutating />;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        // 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
-        class MutationCacheMock extends MutationCacheModule.MutationCache {
-            subscribe(listener) {
-                super.subscribe(listener);
-                return () => void 0;
-            }
-        }
-        const MutationCacheSpy = vi
-            .spyOn(MutationCacheModule, 'MutationCache')
-            .mockImplementation((fn) => {
-            return new MutationCacheMock(fn);
-        });
-        const queryClient = createQueryClient();
-        function IsMutating() {
-            useIsMutating();
-            return null;
-        }
-        function Page() {
-            const [mounted, setMounted] = createSignal(true);
-            const { mutate: mutate1 } = createMutation(() => ({
-                mutationKey: ['mutation1'],
-                mutationFn: async () => {
-                    await sleep(10);
-                    return 'data';
-                },
-            }));
-            createEffect(() => {
-                mutate1();
-            });
-            return (<div>
-          <button onClick={() => setMounted(false)}>unmount</button>
-          <Show when={mounted()}>
-            <IsMutating />
-          </Show>
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        fireEvent.click(screen.getByText('unmount'));
-        // Should not display the console error
-        // "Warning: Can't perform a React state update on an unmounted component"
-        await sleep(20);
-        MutationCacheSpy.mockRestore();
-    });
-});

package/build/source/__tests__/utils.jsx

@@ -1,50 +0,0 @@
-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++;
-    return [`query_${queryKeyCount}`];
-}
-export const Blink = (props) => {
-    const [shouldShow, setShouldShow] = createSignal(true);
-    createEffect(() => {
-        setShouldShow(true);
-        const timeout = setActTimeout(() => setShouldShow(false), props.duration);
-        onCleanup(() => clearTimeout(timeout));
-    });
-    return (<Show when={shouldShow()} fallback={<>off</>}>
-      <>{props.children}</>
-    </Show>);
-};
-export function createQueryClient(config) {
-    return new QueryClient(config);
-}
-export function mockVisibilityState(value) {
-    return vi.spyOn(document, 'visibilityState', 'get').mockReturnValue(value);
-}
-export function mockNavigatorOnLine(value) {
-    return vi.spyOn(navigator, 'onLine', 'get').mockReturnValue(value);
-}
-export function sleep(timeout) {
-    return new Promise((resolve, _reject) => {
-        setTimeout(resolve, timeout);
-    });
-}
-export function setActTimeout(fn, ms) {
-    return setTimeout(() => {
-        fn();
-    }, ms);
-}
-/**
- * Assert the parameter is of a specific type.
- */
-export function expectType(_) {
-    return undefined;
-}
-/**
- * Assert the parameter is not typed as `any`
- */
-export function expectTypeNotAny(_) {
-    return undefined;
-}

package/build/types/__tests__/QueryClientProvider.test.d.ts

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

package/build/types/__tests__/createInfiniteQuery.test.d.ts

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

package/build/types/__tests__/createMutation.test.d.ts

@@ -1 +0,0 @@
-import '@testing-library/jest-dom';

package/build/types/__tests__/createQueries.test.d.ts

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

package/build/types/__tests__/createQuery.test.d.ts

@@ -1 +0,0 @@
-import '@testing-library/jest-dom';

package/build/types/__tests__/createQuery.types.test.d.ts

@@ -1,2 +0,0 @@
-export declare type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
-export declare type Expect<T extends true> = T;

package/build/types/__tests__/suspense.test.d.ts

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

package/build/types/__tests__/transition.test.d.ts

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

package/build/types/__tests__/useIsFetching.test.d.ts

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

package/build/types/__tests__/useIsMutating.test.d.ts

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

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

@@ -1,21 +0,0 @@
-/// <reference types="node" />
-import type { QueryClientConfig } from '@tanstack/query-core';
-import { QueryClient } from '@tanstack/query-core';
-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): 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;
-/**
- * Assert the parameter is of a specific type.
- */
-export declare function expectType<T>(_: T): void;
-/**
- * Assert the parameter is not typed as `any`
- */
-export declare function expectTypeNotAny<T>(_: 0 extends 1 & T ? never : T): void;

package/build/types/createQuery.d.ts

@@ -1,11 +0,0 @@
-import type { QueryClient, QueryKey, DefaultError } from '@tanstack/query-core';
-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;
-}>;
-declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    initialData: TQueryFnData | (() => TQueryFnData);
-}>;
-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/types/types.d.ts

@@ -1,33 +0,0 @@
-import type { QueryKey, QueryObserverOptions, QueryObserverResult, MutateFunction, MutationObserverOptions, MutationObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, WithRequired, DefaultError } from '@tanstack/query-core';
-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;
-}
-export interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends WithRequired<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryKey'> {
-}
-export declare type CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
-export declare type CreateBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
-export declare type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
-export declare type DefinedCreateBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
-export declare type DefinedCreateQueryResult<TData = unknown, TError = DefaultError> = DefinedCreateBaseQueryResult<TData, TError>;
-export interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'queryKey'> {
-    queryKey: TQueryKey;
-    deferStream?: boolean;
-}
-export declare type CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = FunctionedParams<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>>;
-export declare type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
-export interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends Omit<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted' | 'variables'> {
-}
-export declare type CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = FunctionedParams<SolidMutationOptions<TData, TError, TVariables, TContext>>;
-export declare type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
-export declare type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
-export declare type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
-    mutate: CreateMutateFunction<TData, TError, TVariables, TContext>;
-}> & {
-    mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>;
-};
-export declare type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = CreateBaseMutationResult<TData, TError, TVariables, TContext>;
-declare type Override<A, B> = {
-    [K in keyof A]: K extends keyof B ? B[K] : A[K];
-};
-export {};

package/build/umd/index.js

@@ -1,2 +0,0 @@
-!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);const i=r.createContext(void 0),s=e=>{const t=r.useContext(i);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,i,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 i(c(),l),[d,p]=o.createStore(f.getOptimisticResult(l)),m=()=>f.subscribe((e=>{t.notifyManager.batchCalls((()=>{const t={...o.unwrap(e)};g()?.data&&t.data&&!g.loading?(p(t),b(d)):(p(t),h())}))()}));let y=null;const[g,{refetch:h,mutate:b}]=r.createResource((()=>new Promise(((e,r)=>{n.isServer?y=((e,r)=>f.subscribe((n=>{t.notifyManager.batchCalls((()=>{const t={...o.unwrap(n)};t.isError&&("development"===process.env.NODE_ENV&&console.error(t.error),r(t.error)),t.isSuccess&&e(t)}))()})))(e,r):y||(y=m()),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}]}),!y){const e={...l};!l.staleTime&&l.initialData||(e.refetchOnMount=!1),f.setOptions(e),p(f.getOptimisticResult(e)),y=m()}}});r.onCleanup((()=>{y&&(y(),y=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?g()?.data:Reflect.get(e,t)})}function c(){}e.QueryClientContext=i,e.QueryClientProvider=e=>(r.onMount((()=>{e.client.mount()})),r.onCleanup((()=>e.client.unmount())),n.createComponent(i.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 i=s(n?.()),a=new t.MutationObserver(i,e()),l=(e,t)=>{a.mutate(e,t).catch(c)},[f,d]=o.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,n){const i=s(n?.()),u=e().queries.map((e=>{const t=i.defaultQueryOptions(e);return t._optimisticResults="optimistic",t})),a=new t.QueriesObserver(i,u),[c,l]=o.createStore(a.getOptimisticResult(u)),f=a.subscribe((e=>{t.notifyManager.batchCalls((()=>{l(o.unwrap(e))}))()}));return r.onCleanup(f),r.onMount((()=>{a.setQueries(u,{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 a(r.createMemo((()=>e())),t.QueryObserver,n)},e.useIsFetching=function(e,t){const n=r.createMemo((()=>s(t?.()))),o=r.createMemo((()=>n().getQueryCache())),[i,u]=r.createSignal(n().isFetching(e?.())),a=o().subscribe((()=>{u(n().isFetching(e?.()))}));return r.onCleanup(a),i},e.useIsMutating=function(e,t){const n=r.createMemo((()=>s(t?.()))),o=r.createMemo((()=>n().getMutationCache())),[i,u]=r.createSignal(n().isMutating(e?.())),a=o().subscribe((t=>{u(n().isMutating(e?.()))}));return r.onCleanup(a),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]}})}))}));
-//# sourceMappingURL=index.js.map