@tanstack/solid-query 5.0.0-alpha.85 → 5.0.0-alpha.87

package/dist/source/createBaseQuery.js

@@ -1,177 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
-// Had to disable the lint rule because isServer type is defined as false
-// in solid-js/web package. I'll create a GitHub issue with them to see
-// why that happens.
-import { hydrate, notifyManager } from '@tanstack/query-core';
-import { isServer } from 'solid-js/web';
-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.throwOnError = true;
-    }
-    const observer = new Observer(client(), defaultedOptions);
-    const [state, setState] = createStore(observer.getOptimisticResult(defaultedOptions));
-    const createServerSubscriber = (resolve, reject) => {
-        return observer.subscribe((result) => {
-            notifyManager.batchCalls(() => {
-                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,
-                    // Removing these properties since they might not be serializable
-                    // 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);
-                    }
-                    reject(unwrappedResult.error);
-                }
-                if (unwrappedResult.isSuccess) {
-                    // Use of any here is fine
-                    // We cannot include refetch since it is not serializable
-                    resolve(unwrappedResult);
-                }
-            })();
-        });
-    };
-    const createClientSubscriber = () => {
-        return observer.subscribe((result) => {
-            notifyManager.batchCalls(() => {
-                // @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 && result.data && !queryResource.loading) {
-                    setState((store) => {
-                        return reconcileFn(store, result, reconcileOptions === undefined ? 'id' : reconcileOptions);
-                    });
-                    mutate(state);
-                }
-                else {
-                    setState((store) => {
-                        return reconcileFn(store, result, reconcileOptions === undefined ? 'id' : reconcileOptions);
-                    });
-                    refetch();
-                }
-            })();
-        });
-    };
-    /**
-     * Unsubscribe is set lazily, so that we can subscribe after hydration when needed.
-     */
-    let unsubscribe = null;
-    const [queryResource, { refetch, mutate }] = createResource(() => {
-        return new Promise((resolve, reject) => {
-            if (isServer) {
-                unsubscribe = createServerSubscriber(resolve, reject);
-            }
-            else {
-                if (!unsubscribe) {
-                    unsubscribe = createClientSubscriber();
-                }
-            }
-            if (!state.isLoading) {
-                resolve(state);
-            }
-        });
-    }, {
-        initialValue: state,
-        // If initialData is provided, we resolve the resource immediately
-        ssrLoadFrom: options().initialData ? 'initial' : 'server',
-        get deferStream() {
-            return options().deferStream;
-        },
-        /**
-         * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
-         * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
-         *
-         * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
-         *
-         * Note that this is only invoked on the client, for queries that were originally run on the server.
-         */
-        onHydrated(_k, info) {
-            if (info.value) {
-                hydrate(client(), {
-                    queries: [
-                        {
-                            queryKey: defaultedOptions.queryKey,
-                            queryHash: defaultedOptions.queryHash,
-                            state: info.value,
-                        },
-                    ],
-                });
-            }
-            if (!unsubscribe) {
-                /**
-                 * Do not refetch query on mount if query was fetched on server,
-                 * even if `staleTime` is not set.
-                 */
-                const newOptions = { ...defaultedOptions };
-                if (defaultedOptions.staleTime || !defaultedOptions.initialData) {
-                    newOptions.refetchOnMount = false;
-                }
-                // Setting the options as an immutable object to prevent
-                // wonky behavior with observer subscriptions
-                observer.setOptions(newOptions);
-                setState(observer.getOptimisticResult(newOptions));
-                unsubscribe = createClientSubscriber();
-            }
-        },
-    });
-    onCleanup(() => {
-        if (unsubscribe) {
-            unsubscribe();
-            unsubscribe = null;
-        }
-    });
-    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 &&
-            shouldThrowError(observer.options.throwOnError, [
-                state.error,
-                observer.getCurrentQuery(),
-            ])) {
-            throw state.error;
-        }
-    }));
-    const handler = {
-        get(target, prop) {
-            const val = queryResource()?.[prop];
-            return val !== undefined ? val : Reflect.get(target, prop);
-        },
-    };
-    return new Proxy(state, handler);
-}

package/dist/source/createInfiniteQuery.js

@@ -1,8 +0,0 @@
-import { InfiniteQueryObserver } from '@tanstack/query-core';
-import { createMemo } from 'solid-js';
-import { createBaseQuery } from './createBaseQuery';
-export function createInfiniteQuery(options, queryClient) {
-    return createBaseQuery(createMemo(() => options()), 
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-    InfiniteQueryObserver, queryClient);
-}

package/dist/source/createMutation.js

@@ -1,38 +0,0 @@
-import { MutationObserver } from '@tanstack/query-core';
-import { createComputed, on, onCleanup } from 'solid-js';
-import { createStore } from 'solid-js/store';
-import { useQueryClient } from './QueryClientProvider';
-import { shouldThrowError } from './utils';
-// HOOK
-export function createMutation(options, queryClient) {
-    const client = useQueryClient(queryClient?.());
-    const observer = new MutationObserver(client, options());
-    const mutate = (variables, mutateOptions) => {
-        observer.mutate(variables, mutateOptions).catch(noop);
-    };
-    const [state, setState] = createStore({
-        ...observer.getCurrentResult(),
-        mutate,
-        mutateAsync: observer.getCurrentResult().mutate,
-    });
-    createComputed(() => {
-        observer.setOptions(options());
-    });
-    createComputed(on(() => state.status, () => {
-        if (state.isError &&
-            shouldThrowError(observer.options.throwOnError, [state.error])) {
-            throw state.error;
-        }
-    }));
-    const unsubscribe = observer.subscribe((result) => {
-        setState({
-            ...result,
-            mutate,
-            mutateAsync: result.mutate,
-        });
-    });
-    onCleanup(unsubscribe);
-    return state;
-}
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-function noop() { }

package/dist/source/createQueries.js

@@ -1,38 +0,0 @@
-import { QueriesObserver, notifyManager } from '@tanstack/query-core';
-import { createComputed, onCleanup } from 'solid-js';
-import { createStore, unwrap } from 'solid-js/store';
-import { useQueryClient } from './QueryClientProvider';
-export function createQueries(queriesOptions, queryClient) {
-    const client = useQueryClient(queryClient?.());
-    const defaultedQueries = queriesOptions().queries.map((options) => {
-        const defaultedOptions = client.defaultQueryOptions(options);
-        defaultedOptions._optimisticResults = 'optimistic';
-        return defaultedOptions;
-    });
-    const observer = new QueriesObserver(client, defaultedQueries, queriesOptions().combine
-        ? {
-            combine: queriesOptions().combine,
-        }
-        : undefined);
-    // @ts-expect-error - Types issue with solid-js createStore
-    const [state, setState] = createStore(observer.getOptimisticResult(defaultedQueries)[1]());
-    const unsubscribe = observer.subscribe((result) => {
-        notifyManager.batchCalls(() => {
-            setState(unwrap(result));
-        })();
-    });
-    onCleanup(unsubscribe);
-    createComputed(() => {
-        const updatedQueries = queriesOptions().queries.map((options) => {
-            const defaultedOptions = client.defaultQueryOptions(options);
-            defaultedOptions._optimisticResults = 'optimistic';
-            return defaultedOptions;
-        });
-        observer.setQueries(updatedQueries, queriesOptions().combine
-            ? {
-                combine: queriesOptions().combine,
-            }
-            : undefined, { listeners: false });
-    });
-    return state;
-}

package/dist/source/createQuery.js

@@ -1,9 +0,0 @@
-import { QueryObserver } from '@tanstack/query-core';
-import { createMemo } from 'solid-js';
-import { createBaseQuery } from './createBaseQuery';
-export function queryOptions(options) {
-    return options;
-}
-export function createQuery(options, queryClient) {
-    return createBaseQuery(createMemo(() => options()), QueryObserver, queryClient);
-}

package/dist/source/index.js

@@ -1,15 +0,0 @@
-/* istanbul ignore file */
-// Side Effects
-import './setBatchUpdatesFn';
-// Re-export core
-export * from '@tanstack/query-core';
-// Solid Query
-export * from './types';
-export { QueryClient } from './QueryClient';
-export { createQuery, queryOptions } from './createQuery';
-export { QueryClientContext, QueryClientProvider, useQueryClient, } from './QueryClientProvider';
-export { useIsFetching } from './useIsFetching';
-export { createInfiniteQuery } from './createInfiniteQuery';
-export { createMutation } from './createMutation';
-export { useIsMutating } from './useIsMutating';
-export { createQueries } from './createQueries';

package/dist/source/setBatchUpdatesFn.js

@@ -1,3 +0,0 @@
-import { notifyManager } from '@tanstack/query-core';
-import { batch } from 'solid-js';
-notifyManager.setBatchNotifyFunction(batch);

package/dist/source/types.js

@@ -1,2 +0,0 @@
-/* istanbul ignore file */
-export {};

package/dist/source/useIsFetching.js

@@ -1,12 +0,0 @@
-import { createMemo, createSignal, onCleanup } from 'solid-js';
-import { useQueryClient } from './QueryClientProvider';
-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(client().isFetching(filters?.()));
-    });
-    onCleanup(unsubscribe);
-    return fetches;
-}

package/dist/source/useIsMutating.js

@@ -1,12 +0,0 @@
-import { createMemo, createSignal, onCleanup } from 'solid-js';
-import { useQueryClient } from './QueryClientProvider';
-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(client().isMutating(filters?.()));
-    });
-    onCleanup(unsubscribe);
-    return mutations;
-}

package/dist/source/utils.js

@@ -1,7 +0,0 @@
-export function shouldThrowError(throwError, params) {
-    // Allow throwError function to override throwing behavior on a per-error basis
-    if (typeof throwError === 'function') {
-        return throwError(...params);
-    }
-    return !!throwError;
-}

package/dist/types/QueryClient.d.ts

@@ -1,29 +0,0 @@
-import { QueryClient as QueryCoreClient } from '@tanstack/query-core';
-import type { DefaultOptions as CoreDefaultOptions, DefaultError, QueryClientConfig as QueryCoreClientConfig, InfiniteQueryObserverOptions as QueryCoreInfiniteQueryObserverOptions, QueryObserverOptions as QueryCoreObserverOptions, QueryKey } 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/dist/types/QueryClientProvider.d.ts

@@ -1,9 +0,0 @@
-import type { QueryClient } from './QueryClient';
-import type { JSX } from 'solid-js';
-export declare const QueryClientContext: import("solid-js").Context<QueryClient>;
-export declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
-export type QueryClientProviderProps = {
-    client: QueryClient;
-    children?: JSX.Element;
-};
-export declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;

package/dist/types/createBaseQuery.d.ts

@@ -1,5 +0,0 @@
-import type { CreateBaseQueryOptions } from './types';
-import type { Accessor } from 'solid-js';
-import type { QueryClient } from './QueryClient';
-import type { QueryKey, QueryObserver, QueryObserverResult } from '@tanstack/query-core';
-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/dist/types/createInfiniteQuery.d.ts

@@ -1,5 +0,0 @@
-import type { DefaultError, InfiniteData, QueryKey } from '@tanstack/query-core';
-import type { QueryClient } from './QueryClient';
-import type { CreateInfiniteQueryOptions, CreateInfiniteQueryResult } from './types';
-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/dist/types/createMutation.d.ts

@@ -1,5 +0,0 @@
-import type { DefaultError } from '@tanstack/query-core';
-import type { QueryClient } from './QueryClient';
-import type { CreateMutationOptions, CreateMutationResult } from './types';
-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/dist/types/createQueries.d.ts

@@ -1,53 +0,0 @@
-import type { Accessor } from 'solid-js';
-import type { QueryClient } from './QueryClient';
-import type { DefaultError, QueriesPlaceholderDataFunction, QueryFunction, QueryKey } from '@tanstack/query-core';
-import type { CreateQueryResult, SolidQueryOptions } from './types';
-type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData'> & {
-    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
-};
-type MAXIMUM_DEPTH = 20;
-type GetOptions<T> = T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-    data: infer TData;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? CreateQueryOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryOptionsForCreateQueries<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
-    select: (data: any) => infer TData;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TData, TQueryKey> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
-} ? CreateQueryOptionsForCreateQueries<TQueryFnData, Error, TQueryFnData, TQueryKey> : CreateQueryOptionsForCreateQueries;
-type GetResults<T> = T extends {
-    queryFnData: any;
-    error?: infer TError;
-    data: infer TData;
-} ? CreateQueryResult<TData, TError> : T extends {
-    queryFnData: infer TQueryFnData;
-    error?: infer TError;
-} ? CreateQueryResult<TQueryFnData, TError> : T extends {
-    data: infer TData;
-    error?: infer TError;
-} ? CreateQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? CreateQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? CreateQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryResult<TQueryFnData> : T extends {
-    queryFn?: QueryFunction<unknown, any>;
-    select: (data: any) => infer TData;
-} ? CreateQueryResult<TData> : T extends {
-    queryFn?: QueryFunction<infer TQueryFnData, any>;
-} ? CreateQueryResult<TQueryFnData> : CreateQueryResult;
-/**
- * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
- */
-export type QueriesOptions<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? CreateQueryOptionsForCreateQueries[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]> : unknown[] extends T ? T : T extends CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>[] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>[] : CreateQueryOptionsForCreateQueries[];
-/**
- * QueriesResults reducer recursively maps type param to results
- */
-export 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[], TCombinedResult = QueriesResults<T>>(queriesOptions: Accessor<{
-    queries: readonly [...QueriesOptions<T>];
-    combine?: (result: QueriesResults<T>) => TCombinedResult;
-}>, queryClient?: Accessor<QueryClient>): TCombinedResult;
-export {};

package/dist/types/createQuery.d.ts

@@ -1,14 +0,0 @@
-import type { DefaultError, QueryKey } from '@tanstack/query-core';
-import type { QueryClient } from './QueryClient';
-import type { CreateQueryResult, DefinedCreateQueryResult, FunctionedParams, SolidQueryOptions } from './types';
-type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    initialData?: undefined;
-}>;
-type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-    initialData: TQueryFnData | (() => TQueryFnData);
-}>;
-export declare function queryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>;
-export declare function queryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>;
-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/dist/types/index.d.ts

@@ -1,13 +0,0 @@
-import './setBatchUpdatesFn';
-export * from '@tanstack/query-core';
-export * from './types';
-export { QueryClient } from './QueryClient';
-export type { QueryObserverOptions, DefaultOptions, QueryClientConfig, InfiniteQueryObserverOptions, } from './QueryClient';
-export { createQuery, queryOptions } from './createQuery';
-export { QueryClientContext, QueryClientProvider, useQueryClient, } from './QueryClientProvider';
-export type { QueryClientProviderProps } from './QueryClientProvider';
-export { useIsFetching } from './useIsFetching';
-export { createInfiniteQuery } from './createInfiniteQuery';
-export { createMutation } from './createMutation';
-export { useIsMutating } from './useIsMutating';
-export { createQueries } from './createQueries';

package/dist/types/setBatchUpdatesFn.d.ts

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

package/dist/types/types.d.ts

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

package/dist/types/useIsFetching.d.ts

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

package/dist/types/useIsMutating.d.ts

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

package/dist/types/utils.d.ts

@@ -1 +0,0 @@
-export declare function shouldThrowError<T extends (...args: any[]) => boolean>(throwError: boolean | T | undefined, params: Parameters<T>): boolean;