@tanstack/solid-query 5.0.0-alpha.86 → 5.0.0-alpha.88

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;