Mike/FrenoCorp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

FRE-600: Fix code review blockers

Browse Source 
- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>
This commit is contained in:
Michael Freno
2026-04-25 00:08:01 -04:00
parent 65b552bb08
commit 7c684a42cc
48450 changed files with 5679671 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

788
node_modules/@tanstack/solid-query/build/_tsup-dts-rollup.d.cts generated vendored Normal file
View File

@@ -0,0 +1,788 @@
import type { Accessor } from 'solid-js';
import { AnyDataTag } from '@tanstack/query-core';
import { CancelledError } from '@tanstack/query-core';
import { CancelOptions } from '@tanstack/query-core';
import { Context } from 'solid-js';
import { ContextProviderComponent } from 'solid-js';
import { DataTag } from '@tanstack/query-core';
import { dataTagErrorSymbol } from '@tanstack/query-core';
import { dataTagSymbol } from '@tanstack/query-core';
import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
import { DefaultError } from '@tanstack/query-core';
import type { DefaultOptions as DefaultOptions_2 } from '@tanstack/query-core';
import { defaultScheduler } from '@tanstack/query-core';
import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
import { DefinedQueryObserverResult } from '@tanstack/query-core';
import { dehydrate } from '@tanstack/query-core';
import { DehydratedState } from '@tanstack/query-core';
import { DehydrateOptions } from '@tanstack/query-core';
import { DistributiveOmit } from '@tanstack/query-core';
import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
import { EnsureQueryDataOptions } from '@tanstack/query-core';
import { environmentManager } from '@tanstack/query-core';
import { experimental_streamedQuery } from '@tanstack/query-core';
import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
import { FetchNextPageOptions } from '@tanstack/query-core';
import { FetchPreviousPageOptions } from '@tanstack/query-core';
import { FetchQueryOptions } from '@tanstack/query-core';
import { FetchStatus } from '@tanstack/query-core';
import { focusManager } from '@tanstack/query-core';
import { GetNextPageParamFunction } from '@tanstack/query-core';
import { GetPreviousPageParamFunction } from '@tanstack/query-core';
import { hashKey } from '@tanstack/query-core';
import { hydrate } from '@tanstack/query-core';
import { HydrateOptions } from '@tanstack/query-core';
import { InferDataFromTag } from '@tanstack/query-core';
import { InferErrorFromTag } from '@tanstack/query-core';
import { InfiniteData } from '@tanstack/query-core';
import { InfiniteQueryObserver } from '@tanstack/query-core';
import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
import type { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_2 } from '@tanstack/query-core';
import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
import { InfiniteQueryObserverResult } from '@tanstack/query-core';
import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
import { InitialDataFunction } from '@tanstack/query-core';
import { InitialPageParam } from '@tanstack/query-core';
import { InvalidateOptions } from '@tanstack/query-core';
import { InvalidateQueryFilters } from '@tanstack/query-core';
import { isCancelledError } from '@tanstack/query-core';
import { isServer } from '@tanstack/query-core';
import type { JSX } from 'solid-js';
import { keepPreviousData } from '@tanstack/query-core';
import { ManagedTimerId } from '@tanstack/query-core';
import { matchMutation } from '@tanstack/query-core';
import { matchQuery } from '@tanstack/query-core';
import { MutateFunction } from '@tanstack/query-core';
import { MutateOptions } from '@tanstack/query-core';
import { Mutation } from '@tanstack/query-core';
import { MutationCache } from '@tanstack/query-core';
import { MutationCacheNotifyEvent } from '@tanstack/query-core';
import { MutationFilters } from '@tanstack/query-core';
import { MutationFunction } from '@tanstack/query-core';
import { MutationFunctionContext } from '@tanstack/query-core';
import { MutationKey } from '@tanstack/query-core';
import { MutationMeta } from '@tanstack/query-core';
import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
import { MutationObserverBaseResult } from '@tanstack/query-core';
import { MutationObserverErrorResult } from '@tanstack/query-core';
import { MutationObserverIdleResult } from '@tanstack/query-core';
import { MutationObserverLoadingResult } from '@tanstack/query-core';
import { MutationObserverOptions } from '@tanstack/query-core';
import { MutationObserverResult } from '@tanstack/query-core';
import { MutationObserverSuccessResult } from '@tanstack/query-core';
import { MutationOptions } from '@tanstack/query-core';
import { MutationScope } from '@tanstack/query-core';
import { MutationState } from '@tanstack/query-core';
import { MutationStatus } from '@tanstack/query-core';
import { NetworkMode } from '@tanstack/query-core';
import { NoInfer as NoInfer_2 } from '@tanstack/query-core';
import { NonUndefinedGuard } from '@tanstack/query-core';
import { noop } from '@tanstack/query-core';
import { NotifyEvent } from '@tanstack/query-core';
import { NotifyEventType } from '@tanstack/query-core';
import { notifyManager } from '@tanstack/query-core';
import { NotifyOnChangeProps } from '@tanstack/query-core';
import { OmitKeyof } from '@tanstack/query-core';
import { onlineManager } from '@tanstack/query-core';
import { Override } from '@tanstack/query-core';
import { partialMatchKey } from '@tanstack/query-core';
import { PlaceholderDataFunction } from '@tanstack/query-core';
import { QueriesObserver } from '@tanstack/query-core';
import { QueriesObserverOptions } from '@tanstack/query-core';
import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
import { Query } from '@tanstack/query-core';
import { QueryBooleanOption } from '@tanstack/query-core';
import { QueryCache } from '@tanstack/query-core';
import { QueryCacheNotifyEvent } from '@tanstack/query-core';
import { QueryClient as QueryClient_2 } from '@tanstack/query-core';
import type { QueryClientConfig as QueryClientConfig_2 } from '@tanstack/query-core';
import { QueryFilters } from '@tanstack/query-core';
import { QueryFunction } from '@tanstack/query-core';
import { QueryFunctionContext } from '@tanstack/query-core';
import { QueryKey } from '@tanstack/query-core';
import { QueryKeyHashFunction } from '@tanstack/query-core';
import { QueryMeta } from '@tanstack/query-core';
import { QueryObserver } from '@tanstack/query-core';
import { QueryObserverBaseResult } from '@tanstack/query-core';
import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
import { QueryObserverLoadingResult } from '@tanstack/query-core';
import type { QueryObserverOptions as QueryObserverOptions_2 } from '@tanstack/query-core';
import { QueryObserverPendingResult } from '@tanstack/query-core';
import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
import { QueryObserverResult } from '@tanstack/query-core';
import { QueryObserverSuccessResult } from '@tanstack/query-core';
import { QueryOptions } from '@tanstack/query-core';
import { QueryPersister } from '@tanstack/query-core';
import { QueryState } from '@tanstack/query-core';
import { QueryStatus } from '@tanstack/query-core';
import { RefetchOptions } from '@tanstack/query-core';
import { RefetchQueryFilters } from '@tanstack/query-core';
import { Register } from '@tanstack/query-core';
import { replaceEqualDeep } from '@tanstack/query-core';
import { ResetOptions } from '@tanstack/query-core';
import { ResultOptions } from '@tanstack/query-core';
import { SetDataOptions } from '@tanstack/query-core';
import { shouldThrowError } from '@tanstack/query-core';
import { SkipToken } from '@tanstack/query-core';
import { skipToken } from '@tanstack/query-core';
import { StaleTime } from '@tanstack/query-core';
import { StaleTimeFunction } from '@tanstack/query-core';
import { ThrowOnError } from '@tanstack/query-core';
import { TimeoutCallback } from '@tanstack/query-core';
import { timeoutManager } from '@tanstack/query-core';
import { TimeoutProvider } from '@tanstack/query-core';
import { UnsetMarker } from '@tanstack/query-core';
import { unsetMarker } from '@tanstack/query-core';
import { Updater } from '@tanstack/query-core';
import { WithRequired } from '@tanstack/query-core';
export { AnyDataTag }
export { CancelledError }
export { CancelOptions }
export declare const createInfiniteQuery: typeof useInfiniteQuery;
export declare const createMutation: typeof useMutation;
export declare const createQueries: typeof useQueries;
export declare const createQuery: typeof useQuery;
export { DataTag }
export { dataTagErrorSymbol }
export { dataTagSymbol }
export { DefaultedInfiniteQueryObserverOptions }
export { DefaultedQueryObserverOptions }
export { DefaultError }
declare interface DefaultOptions<TError = DefaultError> extends DefaultOptions_2<TError> {
queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
}
export { DefaultOptions }
export { DefaultOptions as DefaultOptions_alias_1 }
export { defaultScheduler }
export { defaultShouldDehydrateMutation }
export { defaultShouldDehydrateQuery }
export { DefinedInfiniteQueryObserverResult }
declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>);
}>;
export { DefinedInitialDataInfiniteOptions }
export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }
declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
initialData: TQueryFnData | (() => TQueryFnData);
}>;
export { DefinedInitialDataOptions }
export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }
export { DefinedQueryObserverResult }
declare type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
export { DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult }
export { DefinedUseBaseQueryResult }
export { DefinedUseBaseQueryResult as DefinedUseBaseQueryResult_alias_1 }
declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
export { DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult }
export { DefinedUseInfiniteQueryResult }
export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }
declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
export { DefinedUseQueryResult as DefinedCreateQueryResult }
export { DefinedUseQueryResult }
export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }
export { dehydrate }
export { DehydratedState }
export { DehydrateOptions }
export { DistributiveOmit }
export { EnsureInfiniteQueryDataOptions }
export { EnsureQueryDataOptions }
export { environmentManager }
export { experimental_streamedQuery }
export { FetchInfiniteQueryOptions }
export { FetchNextPageOptions }
export { FetchPreviousPageOptions }
export { FetchQueryOptions }
export { FetchStatus }
export { focusManager }
export { GetNextPageParamFunction }
declare type GetOptions<T> = T extends {
queryFnData: infer TQueryFnData;
error?: infer TError;
data: infer TData;
} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
queryFnData: infer TQueryFnData;
error?: infer TError;
} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
data: infer TData;
error?: infer TError;
} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
select?: (data: any) => infer TData;
throwOnError?: ThrowOnError<any, infer TError, any, any>;
} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
export { GetPreviousPageParamFunction }
declare type GetResults<T> = T extends {
queryFnData: any;
error?: infer TError;
data: infer TData;
} ? UseQueryResult<TData, TError> : T extends {
queryFnData: infer TQueryFnData;
error?: infer TError;
} ? UseQueryResult<TQueryFnData, TError> : T extends {
data: infer TData;
error?: infer TError;
} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
select?: (data: any) => infer TData;
throwOnError?: ThrowOnError<any, infer TError, any, any>;
} ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
export { hashKey }
export { hydrate }
export { HydrateOptions }
export { InferDataFromTag }
export { InferErrorFromTag }
export { InfiniteData }
export { InfiniteQueryObserver }
export { InfiniteQueryObserverBaseResult }
export { InfiniteQueryObserverLoadingErrorResult }
export { InfiniteQueryObserverLoadingResult }
declare interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions_2<TQueryFnData, TError, TData, 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 to false.
*/
reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
}
export { InfiniteQueryObserverOptions }
export { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_alias_1 }
export { InfiniteQueryObserverPendingResult }
export { InfiniteQueryObserverPlaceholderResult }
export { InfiniteQueryObserverRefetchErrorResult }
export { InfiniteQueryObserverResult }
export { InfiniteQueryObserverSuccessResult }
declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
};
declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
};
export { infiniteQueryOptions }
export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }
export { InfiniteQueryPageParamsOptions }
export { InitialDataFunction }
export { InitialPageParam }
export { InvalidateOptions }
export { InvalidateQueryFilters }
export { isCancelledError }
declare const IsRestoringProvider: ContextProviderComponent<Accessor<boolean>>;
export { IsRestoringProvider }
export { IsRestoringProvider as IsRestoringProvider_alias_1 }
export { isServer }
export { keepPreviousData }
export { ManagedTimerId }
export { matchMutation }
export { matchQuery }
declare type MAXIMUM_DEPTH = 20;
export { MutateFunction }
export { MutateOptions }
export { Mutation }
export { MutationCache }
export { MutationCacheNotifyEvent }
export { MutationFilters }
export { MutationFunction }
export { MutationFunctionContext }
export { MutationKey }
export { MutationMeta }
export { MutationObserver_2 as MutationObserver }
export { MutationObserverBaseResult }
export { MutationObserverErrorResult }
export { MutationObserverIdleResult }
export { MutationObserverLoadingResult }
export { MutationObserverOptions }
export { MutationObserverResult }
export { MutationObserverSuccessResult }
export { MutationOptions }
declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
export { mutationOptions }
export { mutationOptions as mutationOptions_alias_1 }
export { MutationScope }
export { MutationState }
declare type MutationStateOptions<TResult = MutationState> = {
filters?: MutationFilters;
select?: (mutation: Mutation) => TResult;
};
export { MutationStatus }
export { NetworkMode }
export { NoInfer_2 as NoInfer }
export { NonUndefinedGuard }
export { noop }
export { NotifyEvent }
export { NotifyEventType }
export { notifyManager }
export { NotifyOnChangeProps }
export { OmitKeyof }
export { onlineManager }
export { Override }
export { partialMatchKey }
export { PlaceholderDataFunction }
export { QueriesObserver }
export { QueriesObserverOptions }
/**
* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
*/
declare type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
...Tail
], [
...TResult,
GetOptions<Head>
], [
...TDepth,
1
]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
export { QueriesPlaceholderDataFunction }
/**
* QueriesResults reducer recursively maps type param to results
*/
declare type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
...Tail
], [
...TResult,
GetResults<Head>
], [
...TDepth,
1
]> : {
[K in keyof T]: GetResults<T[K]>;
};
export { Query }
export { QueryBooleanOption }
export { QueryCache }
export { QueryCacheNotifyEvent }
declare class QueryClient extends QueryClient_2 {
constructor(config?: QueryClientConfig);
}
export { QueryClient }
export { QueryClient as QueryClient_alias_1 }
declare interface QueryClientConfig extends QueryClientConfig_2 {
defaultOptions?: DefaultOptions;
}
export { QueryClientConfig }
export { QueryClientConfig as QueryClientConfig_alias_1 }
declare const QueryClientContext: Context<(() => QueryClient) | undefined>;
export { QueryClientContext }
export { QueryClientContext as QueryClientContext_alias_1 }
declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
export { QueryClientProvider }
export { QueryClientProvider as QueryClientProvider_alias_1 }
declare type QueryClientProviderProps = {
client: QueryClient;
children?: JSX.Element;
};
export { QueryClientProviderProps }
export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }
export { QueryFilters }
export { QueryFunction }
export { QueryFunctionContext }
export { QueryKey }
export { QueryKeyHashFunction }
export { QueryMeta }
export { QueryObserver }
export { QueryObserverBaseResult }
export { QueryObserverLoadingErrorResult }
export { QueryObserverLoadingResult }
declare interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions_2<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 to false.
*/
reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
}
export { QueryObserverOptions }
export { QueryObserverOptions as QueryObserverOptions_alias_1 }
export { QueryObserverPendingResult }
export { QueryObserverPlaceholderResult }
export { QueryObserverRefetchErrorResult }
export { QueryObserverResult }
export { QueryObserverSuccessResult }
export { QueryOptions }
declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
};
declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
};
export { queryOptions }
export { queryOptions as queryOptions_alias_1 }
export { QueryPersister }
export { QueryState }
export { QueryStatus }
export { RefetchOptions }
export { RefetchQueryFilters }
export { Register }
export { replaceEqualDeep }
export { ResetOptions }
export { ResultOptions }
export { SetDataOptions }
export { shouldThrowError }
export { SkipToken }
export { skipToken }
declare type SkipTokenForUseQueries = symbol;
declare interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'suspense'> {
queryKey: TQueryKey;
/**
* Only applicable while rendering queries on the server with streaming.
* Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
* This can be useful to avoid sending a loading state to the client before the query has resolved.
* Defaults to `false`.
*/
deferStream?: boolean;
/**
* @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
* The `data` property on useInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
* Setting `suspense` to `false` will be a no-op.
*/
suspense?: boolean;
}
export { SolidInfiniteQueryOptions }
export { SolidInfiniteQueryOptions as SolidInfiniteQueryOptions_alias_1 }
declare interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
}
export { SolidMutationOptions }
export { SolidMutationOptions as SolidMutationOptions_alias_1 }
declare interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
}
export { SolidQueryOptions }
export { SolidQueryOptions as SolidQueryOptions_alias_1 }
export { StaleTime }
export { StaleTimeFunction }
export { ThrowOnError }
export { TimeoutCallback }
export { timeoutManager }
export { TimeoutProvider }
declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
initialData?: undefined;
}>;
export { UndefinedInitialDataInfiniteOptions }
export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }
declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
initialData?: undefined;
}>;
export { UndefinedInitialDataOptions }
export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }
export { UnsetMarker }
export { unsetMarker }
export { Updater }
declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
}> & {
mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
};
export { UseBaseMutationResult as CreateBaseMutationResult }
export { UseBaseMutationResult }
export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }
export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): QueryObserverResult<TData, TError>;
declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
/**
* Only applicable while rendering queries on the server with streaming.
* Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
* This can be useful to avoid sending a loading state to the client before the query has resolved.
* Defaults to `false`.
*/
deferStream?: boolean;
/**
* @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
* The `data` property on useQuery is a SolidJS resource and will automatically suspend when the data is loading.
* Setting `suspense` to `false` will be a no-op.
*/
suspense?: boolean;
}
export { UseBaseQueryOptions as CreateBaseQueryOptions }
export { UseBaseQueryOptions }
export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }
declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
export { UseBaseQueryResult as CreateBaseQueryResult }
export { UseBaseQueryResult }
export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }
declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedUseInfiniteQueryResult<TData, TError>;
declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): UseInfiniteQueryResult<TData, TError>;
export { useInfiniteQuery }
export { useInfiniteQuery as useInfiniteQuery_alias_1 }
declare type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>;
export { UseInfiniteQueryOptions as CreateInfiniteQueryOptions }
export { UseInfiniteQueryOptions }
export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }
declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
export { UseInfiniteQueryResult as CreateInfiniteQueryResult }
export { UseInfiniteQueryResult }
export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }
declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
export { useIsFetching as createIsFetching }
export { useIsFetching }
export { useIsFetching as useIsFetching_alias_1 }
declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
export { useIsMutating as createIsMutating }
export { useIsMutating }
export { useIsMutating as useIsMutating_alias_1 }
declare const useIsRestoring: () => Accessor<boolean>;
export { useIsRestoring }
export { useIsRestoring as useIsRestoring_alias_1 }
declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
export { UseMutateAsyncFunction as CreateMutateAsyncFunction }
export { UseMutateAsyncFunction }
export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }
declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
export { UseMutateFunction as CreateMutateFunction }
export { UseMutateFunction }
export { UseMutateFunction as UseMutateFunction_alias_1 }
declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
export { useMutation }
export { useMutation as useMutation_alias_1 }
declare type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = Accessor<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>>;
export { UseMutationOptions as CreateMutationOptions }
export { UseMutationOptions }
export { UseMutationOptions as UseMutationOptions_alias_1 }
declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
export { UseMutationResult as CreateMutationResult }
export { UseMutationResult }
export { UseMutationResult as UseMutationResult_alias_1 }
declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
export { useMutationState as createMutationState }
export { useMutationState }
export { useMutationState as useMutationState_alias_1 }
declare function useQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
queries: readonly [...QueriesOptions<T>] | readonly [...{
[K in keyof T]: GetOptions<T[K]>;
}];
combine?: (result: QueriesResults<T>) => TCombinedResult;
}>, queryClient?: Accessor<QueryClient>): TCombinedResult;
export { useQueries }
export { useQueries as useQueries_alias_1 }
declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;
declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
export { useQuery }
export { useQuery as useQuery_alias_1 }
declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
export { useQueryClient }
export { useQueryClient as useQueryClient_alias_1 }
declare type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
export { UseQueryOptions as CreateQueryOptions }
export { UseQueryOptions }
export { UseQueryOptions as UseQueryOptions_alias_1 }
declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
/**
* @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
* The `data` property on useQueries is a plain object and not a SolidJS Resource.
* It will not suspend when the data is loading.
* Setting `suspense` to `true` will be a no-op.
*/
suspense?: boolean;
};
declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
export { UseQueryResult as CreateQueryResult }
export { UseQueryResult }
export { UseQueryResult as UseQueryResult_alias_1 }
export { WithRequired }
export { }

788
node_modules/@tanstack/solid-query/build/_tsup-dts-rollup.d.ts generated vendored Normal file
View File

@@ -0,0 +1,788 @@
import type { Accessor } from 'solid-js';
import { AnyDataTag } from '@tanstack/query-core';
import { CancelledError } from '@tanstack/query-core';
import { CancelOptions } from '@tanstack/query-core';
import { Context } from 'solid-js';
import { ContextProviderComponent } from 'solid-js';
import { DataTag } from '@tanstack/query-core';
import { dataTagErrorSymbol } from '@tanstack/query-core';
import { dataTagSymbol } from '@tanstack/query-core';
import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
import { DefaultError } from '@tanstack/query-core';
import type { DefaultOptions as DefaultOptions_2 } from '@tanstack/query-core';
import { defaultScheduler } from '@tanstack/query-core';
import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
import { DefinedQueryObserverResult } from '@tanstack/query-core';
import { dehydrate } from '@tanstack/query-core';
import { DehydratedState } from '@tanstack/query-core';
import { DehydrateOptions } from '@tanstack/query-core';
import { DistributiveOmit } from '@tanstack/query-core';
import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
import { EnsureQueryDataOptions } from '@tanstack/query-core';
import { environmentManager } from '@tanstack/query-core';
import { experimental_streamedQuery } from '@tanstack/query-core';
import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
import { FetchNextPageOptions } from '@tanstack/query-core';
import { FetchPreviousPageOptions } from '@tanstack/query-core';
import { FetchQueryOptions } from '@tanstack/query-core';
import { FetchStatus } from '@tanstack/query-core';
import { focusManager } from '@tanstack/query-core';
import { GetNextPageParamFunction } from '@tanstack/query-core';
import { GetPreviousPageParamFunction } from '@tanstack/query-core';
import { hashKey } from '@tanstack/query-core';
import { hydrate } from '@tanstack/query-core';
import { HydrateOptions } from '@tanstack/query-core';
import { InferDataFromTag } from '@tanstack/query-core';
import { InferErrorFromTag } from '@tanstack/query-core';
import { InfiniteData } from '@tanstack/query-core';
import { InfiniteQueryObserver } from '@tanstack/query-core';
import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
import type { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_2 } from '@tanstack/query-core';
import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
import { InfiniteQueryObserverResult } from '@tanstack/query-core';
import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
import { InitialDataFunction } from '@tanstack/query-core';
import { InitialPageParam } from '@tanstack/query-core';
import { InvalidateOptions } from '@tanstack/query-core';
import { InvalidateQueryFilters } from '@tanstack/query-core';
import { isCancelledError } from '@tanstack/query-core';
import { isServer } from '@tanstack/query-core';
import type { JSX } from 'solid-js';
import { keepPreviousData } from '@tanstack/query-core';
import { ManagedTimerId } from '@tanstack/query-core';
import { matchMutation } from '@tanstack/query-core';
import { matchQuery } from '@tanstack/query-core';
import { MutateFunction } from '@tanstack/query-core';
import { MutateOptions } from '@tanstack/query-core';
import { Mutation } from '@tanstack/query-core';
import { MutationCache } from '@tanstack/query-core';
import { MutationCacheNotifyEvent } from '@tanstack/query-core';
import { MutationFilters } from '@tanstack/query-core';
import { MutationFunction } from '@tanstack/query-core';
import { MutationFunctionContext } from '@tanstack/query-core';
import { MutationKey } from '@tanstack/query-core';
import { MutationMeta } from '@tanstack/query-core';
import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
import { MutationObserverBaseResult } from '@tanstack/query-core';
import { MutationObserverErrorResult } from '@tanstack/query-core';
import { MutationObserverIdleResult } from '@tanstack/query-core';
import { MutationObserverLoadingResult } from '@tanstack/query-core';
import { MutationObserverOptions } from '@tanstack/query-core';
import { MutationObserverResult } from '@tanstack/query-core';
import { MutationObserverSuccessResult } from '@tanstack/query-core';
import { MutationOptions } from '@tanstack/query-core';
import { MutationScope } from '@tanstack/query-core';
import { MutationState } from '@tanstack/query-core';
import { MutationStatus } from '@tanstack/query-core';
import { NetworkMode } from '@tanstack/query-core';
import { NoInfer as NoInfer_2 } from '@tanstack/query-core';
import { NonUndefinedGuard } from '@tanstack/query-core';
import { noop } from '@tanstack/query-core';
import { NotifyEvent } from '@tanstack/query-core';
import { NotifyEventType } from '@tanstack/query-core';
import { notifyManager } from '@tanstack/query-core';
import { NotifyOnChangeProps } from '@tanstack/query-core';
import { OmitKeyof } from '@tanstack/query-core';
import { onlineManager } from '@tanstack/query-core';
import { Override } from '@tanstack/query-core';
import { partialMatchKey } from '@tanstack/query-core';
import { PlaceholderDataFunction } from '@tanstack/query-core';
import { QueriesObserver } from '@tanstack/query-core';
import { QueriesObserverOptions } from '@tanstack/query-core';
import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
import { Query } from '@tanstack/query-core';
import { QueryBooleanOption } from '@tanstack/query-core';
import { QueryCache } from '@tanstack/query-core';
import { QueryCacheNotifyEvent } from '@tanstack/query-core';
import { QueryClient as QueryClient_2 } from '@tanstack/query-core';
import type { QueryClientConfig as QueryClientConfig_2 } from '@tanstack/query-core';
import { QueryFilters } from '@tanstack/query-core';
import { QueryFunction } from '@tanstack/query-core';
import { QueryFunctionContext } from '@tanstack/query-core';
import { QueryKey } from '@tanstack/query-core';
import { QueryKeyHashFunction } from '@tanstack/query-core';
import { QueryMeta } from '@tanstack/query-core';
import { QueryObserver } from '@tanstack/query-core';
import { QueryObserverBaseResult } from '@tanstack/query-core';
import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
import { QueryObserverLoadingResult } from '@tanstack/query-core';
import type { QueryObserverOptions as QueryObserverOptions_2 } from '@tanstack/query-core';
import { QueryObserverPendingResult } from '@tanstack/query-core';
import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
import { QueryObserverResult } from '@tanstack/query-core';
import { QueryObserverSuccessResult } from '@tanstack/query-core';
import { QueryOptions } from '@tanstack/query-core';
import { QueryPersister } from '@tanstack/query-core';
import { QueryState } from '@tanstack/query-core';
import { QueryStatus } from '@tanstack/query-core';
import { RefetchOptions } from '@tanstack/query-core';
import { RefetchQueryFilters } from '@tanstack/query-core';
import { Register } from '@tanstack/query-core';
import { replaceEqualDeep } from '@tanstack/query-core';
import { ResetOptions } from '@tanstack/query-core';
import { ResultOptions } from '@tanstack/query-core';
import { SetDataOptions } from '@tanstack/query-core';
import { shouldThrowError } from '@tanstack/query-core';
import { SkipToken } from '@tanstack/query-core';
import { skipToken } from '@tanstack/query-core';
import { StaleTime } from '@tanstack/query-core';
import { StaleTimeFunction } from '@tanstack/query-core';
import { ThrowOnError } from '@tanstack/query-core';
import { TimeoutCallback } from '@tanstack/query-core';
import { timeoutManager } from '@tanstack/query-core';
import { TimeoutProvider } from '@tanstack/query-core';
import { UnsetMarker } from '@tanstack/query-core';
import { unsetMarker } from '@tanstack/query-core';
import { Updater } from '@tanstack/query-core';
import { WithRequired } from '@tanstack/query-core';
export { AnyDataTag }
export { CancelledError }
export { CancelOptions }
export declare const createInfiniteQuery: typeof useInfiniteQuery;
export declare const createMutation: typeof useMutation;
export declare const createQueries: typeof useQueries;
export declare const createQuery: typeof useQuery;
export { DataTag }
export { dataTagErrorSymbol }
export { dataTagSymbol }
export { DefaultedInfiniteQueryObserverOptions }
export { DefaultedQueryObserverOptions }
export { DefaultError }
declare interface DefaultOptions<TError = DefaultError> extends DefaultOptions_2<TError> {
queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
}
export { DefaultOptions }
export { DefaultOptions as DefaultOptions_alias_1 }
export { defaultScheduler }
export { defaultShouldDehydrateMutation }
export { defaultShouldDehydrateQuery }
export { DefinedInfiniteQueryObserverResult }
declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>);
}>;
export { DefinedInitialDataInfiniteOptions }
export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }
declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
initialData: TQueryFnData | (() => TQueryFnData);
}>;
export { DefinedInitialDataOptions }
export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }
export { DefinedQueryObserverResult }
declare type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
export { DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult }
export { DefinedUseBaseQueryResult }
export { DefinedUseBaseQueryResult as DefinedUseBaseQueryResult_alias_1 }
declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
export { DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult }
export { DefinedUseInfiniteQueryResult }
export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }
declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
export { DefinedUseQueryResult as DefinedCreateQueryResult }
export { DefinedUseQueryResult }
export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }
export { dehydrate }
export { DehydratedState }
export { DehydrateOptions }
export { DistributiveOmit }
export { EnsureInfiniteQueryDataOptions }
export { EnsureQueryDataOptions }
export { environmentManager }
export { experimental_streamedQuery }
export { FetchInfiniteQueryOptions }
export { FetchNextPageOptions }
export { FetchPreviousPageOptions }
export { FetchQueryOptions }
export { FetchStatus }
export { focusManager }
export { GetNextPageParamFunction }
declare type GetOptions<T> = T extends {
queryFnData: infer TQueryFnData;
error?: infer TError;
data: infer TData;
} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
queryFnData: infer TQueryFnData;
error?: infer TError;
} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
data: infer TData;
error?: infer TError;
} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
select?: (data: any) => infer TData;
throwOnError?: ThrowOnError<any, infer TError, any, any>;
} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
export { GetPreviousPageParamFunction }
declare type GetResults<T> = T extends {
queryFnData: any;
error?: infer TError;
data: infer TData;
} ? UseQueryResult<TData, TError> : T extends {
queryFnData: infer TQueryFnData;
error?: infer TError;
} ? UseQueryResult<TQueryFnData, TError> : T extends {
data: infer TData;
error?: infer TError;
} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
select?: (data: any) => infer TData;
throwOnError?: ThrowOnError<any, infer TError, any, any>;
} ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
export { hashKey }
export { hydrate }
export { HydrateOptions }
export { InferDataFromTag }
export { InferErrorFromTag }
export { InfiniteData }
export { InfiniteQueryObserver }
export { InfiniteQueryObserverBaseResult }
export { InfiniteQueryObserverLoadingErrorResult }
export { InfiniteQueryObserverLoadingResult }
declare interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions_2<TQueryFnData, TError, TData, 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 to false.
*/
reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
}
export { InfiniteQueryObserverOptions }
export { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_alias_1 }
export { InfiniteQueryObserverPendingResult }
export { InfiniteQueryObserverPlaceholderResult }
export { InfiniteQueryObserverRefetchErrorResult }
export { InfiniteQueryObserverResult }
export { InfiniteQueryObserverSuccessResult }
declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
};
declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
};
export { infiniteQueryOptions }
export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }
export { InfiniteQueryPageParamsOptions }
export { InitialDataFunction }
export { InitialPageParam }
export { InvalidateOptions }
export { InvalidateQueryFilters }
export { isCancelledError }
declare const IsRestoringProvider: ContextProviderComponent<Accessor<boolean>>;
export { IsRestoringProvider }
export { IsRestoringProvider as IsRestoringProvider_alias_1 }
export { isServer }
export { keepPreviousData }
export { ManagedTimerId }
export { matchMutation }
export { matchQuery }
declare type MAXIMUM_DEPTH = 20;
export { MutateFunction }
export { MutateOptions }
export { Mutation }
export { MutationCache }
export { MutationCacheNotifyEvent }
export { MutationFilters }
export { MutationFunction }
export { MutationFunctionContext }
export { MutationKey }
export { MutationMeta }
export { MutationObserver_2 as MutationObserver }
export { MutationObserverBaseResult }
export { MutationObserverErrorResult }
export { MutationObserverIdleResult }
export { MutationObserverLoadingResult }
export { MutationObserverOptions }
export { MutationObserverResult }
export { MutationObserverSuccessResult }
export { MutationOptions }
declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
export { mutationOptions }
export { mutationOptions as mutationOptions_alias_1 }
export { MutationScope }
export { MutationState }
declare type MutationStateOptions<TResult = MutationState> = {
filters?: MutationFilters;
select?: (mutation: Mutation) => TResult;
};
export { MutationStatus }
export { NetworkMode }
export { NoInfer_2 as NoInfer }
export { NonUndefinedGuard }
export { noop }
export { NotifyEvent }
export { NotifyEventType }
export { notifyManager }
export { NotifyOnChangeProps }
export { OmitKeyof }
export { onlineManager }
export { Override }
export { partialMatchKey }
export { PlaceholderDataFunction }
export { QueriesObserver }
export { QueriesObserverOptions }
/**
* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
*/
declare type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
...Tail
], [
...TResult,
GetOptions<Head>
], [
...TDepth,
1
]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
export { QueriesPlaceholderDataFunction }
/**
* QueriesResults reducer recursively maps type param to results
*/
declare type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
...Tail
], [
...TResult,
GetResults<Head>
], [
...TDepth,
1
]> : {
[K in keyof T]: GetResults<T[K]>;
};
export { Query }
export { QueryBooleanOption }
export { QueryCache }
export { QueryCacheNotifyEvent }
declare class QueryClient extends QueryClient_2 {
constructor(config?: QueryClientConfig);
}
export { QueryClient }
export { QueryClient as QueryClient_alias_1 }
declare interface QueryClientConfig extends QueryClientConfig_2 {
defaultOptions?: DefaultOptions;
}
export { QueryClientConfig }
export { QueryClientConfig as QueryClientConfig_alias_1 }
declare const QueryClientContext: Context<(() => QueryClient) | undefined>;
export { QueryClientContext }
export { QueryClientContext as QueryClientContext_alias_1 }
declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
export { QueryClientProvider }
export { QueryClientProvider as QueryClientProvider_alias_1 }
declare type QueryClientProviderProps = {
client: QueryClient;
children?: JSX.Element;
};
export { QueryClientProviderProps }
export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }
export { QueryFilters }
export { QueryFunction }
export { QueryFunctionContext }
export { QueryKey }
export { QueryKeyHashFunction }
export { QueryMeta }
export { QueryObserver }
export { QueryObserverBaseResult }
export { QueryObserverLoadingErrorResult }
export { QueryObserverLoadingResult }
declare interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions_2<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 to false.
*/
reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
}
export { QueryObserverOptions }
export { QueryObserverOptions as QueryObserverOptions_alias_1 }
export { QueryObserverPendingResult }
export { QueryObserverPlaceholderResult }
export { QueryObserverRefetchErrorResult }
export { QueryObserverResult }
export { QueryObserverSuccessResult }
export { QueryOptions }
declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
};
declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
};
export { queryOptions }
export { queryOptions as queryOptions_alias_1 }
export { QueryPersister }
export { QueryState }
export { QueryStatus }
export { RefetchOptions }
export { RefetchQueryFilters }
export { Register }
export { replaceEqualDeep }
export { ResetOptions }
export { ResultOptions }
export { SetDataOptions }
export { shouldThrowError }
export { SkipToken }
export { skipToken }
declare type SkipTokenForUseQueries = symbol;
declare interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'suspense'> {
queryKey: TQueryKey;
/**
* Only applicable while rendering queries on the server with streaming.
* Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
* This can be useful to avoid sending a loading state to the client before the query has resolved.
* Defaults to `false`.
*/
deferStream?: boolean;
/**
* @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
* The `data` property on useInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
* Setting `suspense` to `false` will be a no-op.
*/
suspense?: boolean;
}
export { SolidInfiniteQueryOptions }
export { SolidInfiniteQueryOptions as SolidInfiniteQueryOptions_alias_1 }
declare interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
}
export { SolidMutationOptions }
export { SolidMutationOptions as SolidMutationOptions_alias_1 }
declare interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
}
export { SolidQueryOptions }
export { SolidQueryOptions as SolidQueryOptions_alias_1 }
export { StaleTime }
export { StaleTimeFunction }
export { ThrowOnError }
export { TimeoutCallback }
export { timeoutManager }
export { TimeoutProvider }
declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
initialData?: undefined;
}>;
export { UndefinedInitialDataInfiniteOptions }
export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }
declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
initialData?: undefined;
}>;
export { UndefinedInitialDataOptions }
export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }
export { UnsetMarker }
export { unsetMarker }
export { Updater }
declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
}> & {
mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
};
export { UseBaseMutationResult as CreateBaseMutationResult }
export { UseBaseMutationResult }
export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }
export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): QueryObserverResult<TData, TError>;
declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
/**
* Only applicable while rendering queries on the server with streaming.
* Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
* This can be useful to avoid sending a loading state to the client before the query has resolved.
* Defaults to `false`.
*/
deferStream?: boolean;
/**
* @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
* The `data` property on useQuery is a SolidJS resource and will automatically suspend when the data is loading.
* Setting `suspense` to `false` will be a no-op.
*/
suspense?: boolean;
}
export { UseBaseQueryOptions as CreateBaseQueryOptions }
export { UseBaseQueryOptions }
export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }
declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
export { UseBaseQueryResult as CreateBaseQueryResult }
export { UseBaseQueryResult }
export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }
declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedUseInfiniteQueryResult<TData, TError>;
declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): UseInfiniteQueryResult<TData, TError>;
export { useInfiniteQuery }
export { useInfiniteQuery as useInfiniteQuery_alias_1 }
declare type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>;
export { UseInfiniteQueryOptions as CreateInfiniteQueryOptions }
export { UseInfiniteQueryOptions }
export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }
declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
export { UseInfiniteQueryResult as CreateInfiniteQueryResult }
export { UseInfiniteQueryResult }
export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }
declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
export { useIsFetching as createIsFetching }
export { useIsFetching }
export { useIsFetching as useIsFetching_alias_1 }
declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
export { useIsMutating as createIsMutating }
export { useIsMutating }
export { useIsMutating as useIsMutating_alias_1 }
declare const useIsRestoring: () => Accessor<boolean>;
export { useIsRestoring }
export { useIsRestoring as useIsRestoring_alias_1 }
declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
export { UseMutateAsyncFunction as CreateMutateAsyncFunction }
export { UseMutateAsyncFunction }
export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }
declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
export { UseMutateFunction as CreateMutateFunction }
export { UseMutateFunction }
export { UseMutateFunction as UseMutateFunction_alias_1 }
declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
export { useMutation }
export { useMutation as useMutation_alias_1 }
declare type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = Accessor<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>>;
export { UseMutationOptions as CreateMutationOptions }
export { UseMutationOptions }
export { UseMutationOptions as UseMutationOptions_alias_1 }
declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
export { UseMutationResult as CreateMutationResult }
export { UseMutationResult }
export { UseMutationResult as UseMutationResult_alias_1 }
declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
export { useMutationState as createMutationState }
export { useMutationState }
export { useMutationState as useMutationState_alias_1 }
declare function useQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
queries: readonly [...QueriesOptions<T>] | readonly [...{
[K in keyof T]: GetOptions<T[K]>;
}];
combine?: (result: QueriesResults<T>) => TCombinedResult;
}>, queryClient?: Accessor<QueryClient>): TCombinedResult;
export { useQueries }
export { useQueries as useQueries_alias_1 }
declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;
declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
export { useQuery }
export { useQuery as useQuery_alias_1 }
declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
export { useQueryClient }
export { useQueryClient as useQueryClient_alias_1 }
declare type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
export { UseQueryOptions as CreateQueryOptions }
export { UseQueryOptions }
export { UseQueryOptions as UseQueryOptions_alias_1 }
declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
/**
* @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
* The `data` property on useQueries is a plain object and not a SolidJS Resource.
* It will not suspend when the data is loading.
* Setting `suspense` to `true` will be a no-op.
*/
suspense?: boolean;
};
declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
export { UseQueryResult as CreateQueryResult }
export { UseQueryResult }
export { UseQueryResult as UseQueryResult_alias_1 }
export { WithRequired }
export { }

549
node_modules/@tanstack/solid-query/build/dev.cjs generated vendored Normal file
View File

@@ -0,0 +1,549 @@
'use strict';
var queryCore = require('@tanstack/query-core');
var solidJs = require('solid-js');
var web = require('solid-js/web');
var store = require('solid-js/store');
// src/useQuery.ts
exports.QueryClientContext = solidJs.createContext(void 0);
exports.useQueryClient = (queryClient) => {
if (queryClient) {
return queryClient;
}
const client = solidJs.useContext(exports.QueryClientContext);
if (!client) {
throw new Error("No QueryClient set, use QueryClientProvider to set one");
}
return client();
};
exports.QueryClientProvider = (props) => {
solidJs.createRenderEffect((unmount) => {
unmount?.();
props.client.mount();
return props.client.unmount.bind(props.client);
});
solidJs.onCleanup(() => props.client.unmount());
return web.createComponent(exports.QueryClientContext.Provider, {
value: () => props.client,
get children() {
return props.children;
}
});
};
var IsRestoringContext = solidJs.createContext(() => false);
exports.useIsRestoring = () => solidJs.useContext(IsRestoringContext);
exports.IsRestoringProvider = IsRestoringContext.Provider;
// src/useBaseQuery.ts
function reconcileFn(store$1, result, reconcileOption, queryHash) {
if (reconcileOption === false) return result;
if (typeof reconcileOption === "function") {
const newData2 = reconcileOption(store$1.data, result.data);
return { ...result, data: newData2 };
}
let data = result.data;
if (store$1.data === void 0) {
try {
data = structuredClone(data);
} catch (error) {
{
if (error instanceof Error) {
console.warn(
`Unable to correctly reconcile data for query key: ${queryHash}. Possibly because the query data contains data structures that aren't supported by the 'structuredClone' algorithm. Consider using a callback function instead to manage the reconciliation manually.
Error Received: ${error.name} - ${error.message}`
);
}
}
}
}
const newData = store.reconcile(data, { key: reconcileOption })(store$1.data);
return { ...result, data: newData };
}
var hydratableObserverResult = (query, result) => {
if (!web.isServer) return result;
const obj = {
...store.unwrap(result),
// During SSR, functions cannot be serialized, so we need to remove them
// This is safe because we will add these functions back when the query is hydrated
refetch: void 0
};
if ("fetchNextPage" in result) {
obj.fetchNextPage = void 0;
obj.fetchPreviousPage = void 0;
}
obj.hydrationData = {
state: query.state,
queryKey: query.queryKey,
queryHash: query.queryHash,
...query.meta && { meta: query.meta }
};
return obj;
};
function useBaseQuery(options, Observer, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const isRestoring = exports.useIsRestoring();
let unsubscribeQueued = false;
const defaultedOptions = solidJs.createMemo(() => {
const defaultOptions = client().defaultQueryOptions(options());
defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
defaultOptions.structuralSharing = false;
if (web.isServer) {
defaultOptions.retry = false;
defaultOptions.throwOnError = true;
defaultOptions.experimental_prefetchInRender = true;
}
return defaultOptions;
});
const initialOptions = defaultedOptions();
const [observer, setObserver] = solidJs.createSignal(
new Observer(client(), defaultedOptions())
);
let observerResult = observer().getOptimisticResult(defaultedOptions());
const [state, setState] = store.createStore(observerResult);
const createServerSubscriber = (resolve, reject) => {
return observer().subscribe((result) => {
queryCore.notifyManager.batchCalls(() => {
const query = observer().getCurrentQuery();
const unwrappedResult = hydratableObserverResult(query, result);
if (result.data !== void 0 && unwrappedResult.isError) {
reject(unwrappedResult.error);
unsubscribeIfQueued();
} else {
resolve(unwrappedResult);
unsubscribeIfQueued();
}
})();
});
};
const unsubscribeIfQueued = () => {
if (unsubscribeQueued) {
unsubscribe?.();
unsubscribeQueued = false;
}
};
const createClientSubscriber = () => {
const obs = observer();
return obs.subscribe((result) => {
observerResult = result;
queueMicrotask(() => {
if (unsubscribe) {
refetch();
}
});
});
};
function setStateWithReconciliation(res) {
const opts = observer().options;
const reconcileOptions = opts.reconcile;
setState((store) => {
return reconcileFn(
store,
res,
reconcileOptions === void 0 ? false : reconcileOptions,
opts.queryHash
);
});
}
function createDeepSignal() {
return [
() => state,
(v) => {
const unwrapped = store.unwrap(state);
if (typeof v === "function") {
v = v(unwrapped);
}
if (v?.hydrationData) {
const { hydrationData, ...rest } = v;
v = rest;
}
setStateWithReconciliation(v);
}
];
}
let unsubscribe = null;
let resolver = null;
const [queryResource, { refetch }] = solidJs.createResource(
() => {
const obs = observer();
return new Promise((resolve, reject) => {
resolver = resolve;
if (web.isServer) {
unsubscribe = createServerSubscriber(resolve, reject);
} else if (!unsubscribe && !isRestoring()) {
unsubscribe = createClientSubscriber();
}
obs.updateResult();
if (observerResult.isError && !observerResult.isFetching && !isRestoring() && queryCore.shouldThrowError(obs.options.throwOnError, [
observerResult.error,
obs.getCurrentQuery()
])) {
setStateWithReconciliation(observerResult);
return reject(observerResult.error);
}
if (!observerResult.isLoading) {
resolver = null;
return resolve(
hydratableObserverResult(obs.getCurrentQuery(), observerResult)
);
}
setStateWithReconciliation(observerResult);
});
},
{
storage: createDeepSignal,
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 && "hydrationData" in info.value) {
queryCore.hydrate(client(), {
// @ts-expect-error - hydrationData is not correctly typed internally
queries: [{ ...info.value.hydrationData }]
});
}
if (unsubscribe) return;
const newOptions = { ...initialOptions };
if ((initialOptions.staleTime || !initialOptions.initialData) && info.value) {
newOptions.refetchOnMount = false;
}
observer().setOptions(newOptions);
setStateWithReconciliation(observer().getOptimisticResult(newOptions));
unsubscribe = createClientSubscriber();
}
}
);
solidJs.createComputed(
solidJs.on(
client,
(c) => {
if (unsubscribe) {
unsubscribe();
}
const newObserver = new Observer(c, defaultedOptions());
unsubscribe = createClientSubscriber();
setObserver(newObserver);
},
{
defer: true
}
)
);
solidJs.createComputed(
solidJs.on(
isRestoring,
(restoring) => {
if (!restoring && !web.isServer) {
refetch();
}
},
{ defer: true }
)
);
solidJs.onCleanup(() => {
if (web.isServer && queryResource.loading) {
unsubscribeQueued = true;
return;
}
if (unsubscribe) {
unsubscribe();
unsubscribe = null;
}
if (resolver && !web.isServer) {
resolver(observerResult);
resolver = null;
}
});
solidJs.createComputed(
solidJs.on(
[observer, defaultedOptions],
([obs, opts]) => {
obs.setOptions(opts);
setStateWithReconciliation(obs.getOptimisticResult(opts));
refetch();
},
{ defer: true }
)
);
const handler = {
get(target, prop) {
if (prop === "data") {
if (state.data !== void 0) {
return queryResource.latest?.data;
}
return queryResource()?.data;
}
return Reflect.get(target, prop);
}
};
return new Proxy(state, handler);
}
// src/useQuery.ts
function useQuery(options, queryClient) {
return useBaseQuery(
solidJs.createMemo(() => options()),
queryCore.QueryObserver,
queryClient
);
}
function useInfiniteQuery(options, queryClient) {
return useBaseQuery(
solidJs.createMemo(() => options()),
queryCore.InfiniteQueryObserver,
queryClient
);
}
function useMutation(options, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const observer = new queryCore.MutationObserver(client(), options());
const mutate = (variables, mutateOptions) => {
observer.mutate(variables, mutateOptions).catch(queryCore.noop);
};
const [state, setState] = store.createStore({
...observer.getCurrentResult(),
mutate,
mutateAsync: observer.getCurrentResult().mutate
});
solidJs.createComputed(() => {
observer.setOptions(options());
});
solidJs.createComputed(
solidJs.on(
() => state.status,
() => {
if (state.isError && queryCore.shouldThrowError(observer.options.throwOnError, [state.error])) {
throw state.error;
}
}
)
);
const unsubscribe = observer.subscribe((result) => {
setState({
...result,
mutate,
mutateAsync: result.mutate
});
});
solidJs.onCleanup(unsubscribe);
return state;
}
function useQueries(queriesOptions, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const isRestoring = exports.useIsRestoring();
const defaultedQueries = solidJs.createMemo(
() => queriesOptions().queries.map(
(options) => solidJs.mergeProps(
client().defaultQueryOptions(options),
{
get _optimisticResults() {
return isRestoring() ? "isRestoring" : "optimistic";
}
}
)
)
);
const observer = new queryCore.QueriesObserver(
client(),
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
const [state, setState] = store.createStore(
observer.getOptimisticResult(
defaultedQueries(),
queriesOptions().combine
)[1]()
);
solidJs.createRenderEffect(
solidJs.on(
() => queriesOptions().queries.length,
() => setState(
observer.getOptimisticResult(
defaultedQueries(),
queriesOptions().combine
)[1]()
)
)
);
const dataResources = solidJs.createMemo(
solidJs.on(
() => state.length,
() => state.map((queryRes) => {
const dataPromise = () => new Promise((resolve) => {
if (queryRes.isFetching && queryRes.isLoading) return;
resolve(store.unwrap(queryRes.data));
});
return solidJs.createResource(dataPromise);
})
)
);
solidJs.batch(() => {
const dataResources_ = dataResources();
for (let index = 0; index < dataResources_.length; index++) {
const dataResource = dataResources_[index];
dataResource[1].mutate(() => store.unwrap(state[index].data));
dataResource[1].refetch();
}
});
let taskQueue = [];
const subscribeToObserver = () => observer.subscribe((result) => {
taskQueue.push(() => {
solidJs.batch(() => {
const dataResources_ = dataResources();
for (let index = 0; index < dataResources_.length; index++) {
const dataResource = dataResources_[index];
const unwrappedResult = { ...store.unwrap(result[index]) };
setState(index, store.unwrap(unwrappedResult));
dataResource[1].mutate(() => store.unwrap(state[index].data));
dataResource[1].refetch();
}
});
});
queueMicrotask(() => {
const taskToRun = taskQueue.pop();
if (taskToRun) taskToRun();
taskQueue = [];
});
});
let unsubscribe = queryCore.noop;
solidJs.createComputed((cleanup) => {
cleanup?.();
unsubscribe = isRestoring() ? queryCore.noop : subscribeToObserver();
return () => queueMicrotask(unsubscribe);
});
solidJs.onCleanup(unsubscribe);
solidJs.onMount(() => {
observer.setQueries(
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
});
solidJs.createComputed(() => {
observer.setQueries(
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
});
const handler = (index) => ({
get(target, prop) {
if (prop === "data") {
return dataResources()[index][0]();
}
return Reflect.get(target, prop);
}
});
const getProxies = () => state.map((s, index) => {
return new Proxy(s, handler(index));
});
const [proxyState, setProxyState] = store.createStore(getProxies());
solidJs.createRenderEffect(() => setProxyState(getProxies()));
return proxyState;
}
exports.QueryClient = class QueryClient extends queryCore.QueryClient {
constructor(config = {}) {
super(config);
}
};
// src/queryOptions.ts
function queryOptions(options) {
return options;
}
function useIsFetching(filters, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const queryCache = solidJs.createMemo(() => client().getQueryCache());
const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
const unsubscribe = queryCache().subscribe(() => {
setFetches(client().isFetching(filters?.()));
});
solidJs.onCleanup(unsubscribe);
return fetches;
}
// src/infiniteQueryOptions.ts
function infiniteQueryOptions(options) {
return options;
}
// src/mutationOptions.ts
function mutationOptions(options) {
return options;
}
function useIsMutating(filters, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const mutationCache = solidJs.createMemo(() => client().getMutationCache());
const [mutations, setMutations] = solidJs.createSignal(
client().isMutating(filters?.())
);
const unsubscribe = mutationCache().subscribe((_result) => {
setMutations(client().isMutating(filters?.()));
});
solidJs.onCleanup(unsubscribe);
return mutations;
}
function getResult(mutationCache, options) {
return mutationCache.findAll(options.filters).map(
(mutation) => options.select ? options.select(mutation) : mutation.state
);
}
function useMutationState(options = () => ({}), queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const mutationCache = solidJs.createMemo(() => client().getMutationCache());
const [result, setResult] = solidJs.createSignal(
getResult(mutationCache(), options())
);
solidJs.createEffect(() => {
const unsubscribe = mutationCache().subscribe(() => {
const nextResult = queryCore.replaceEqualDeep(
result(),
getResult(mutationCache(), options())
);
if (result() !== nextResult) {
setResult(nextResult);
}
});
solidJs.onCleanup(unsubscribe);
});
return result;
}
// src/index.ts
exports.createQuery = useQuery;
exports.createInfiniteQuery = useInfiniteQuery;
exports.createMutation = useMutation;
exports.createQueries = useQueries;
exports.createIsFetching = useIsFetching;
exports.createIsMutating = useIsMutating;
exports.createMutationState = useMutationState;
exports.infiniteQueryOptions = infiniteQueryOptions;
exports.mutationOptions = mutationOptions;
exports.queryOptions = queryOptions;
exports.useInfiniteQuery = useInfiniteQuery;
exports.useIsFetching = useIsFetching;
exports.useIsMutating = useIsMutating;
exports.useMutation = useMutation;
exports.useMutationState = useMutationState;
exports.useQueries = useQueries;
exports.useQuery = useQuery;
Object.keys(queryCore).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return queryCore[k]; }
});
});

200
node_modules/@tanstack/solid-query/build/dev.d.cts generated vendored Normal file
View File

@@ -0,0 +1,200 @@
export { DefinedUseBaseQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedUseQueryResult } from './_tsup-dts-rollup.cjs';
export { SolidInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { SolidMutationOptions } from './_tsup-dts-rollup.cjs';
export { SolidQueryOptions } from './_tsup-dts-rollup.cjs';
export { UseBaseMutationResult } from './_tsup-dts-rollup.cjs';
export { UseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
export { UseBaseQueryResult } from './_tsup-dts-rollup.cjs';
export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { UseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
export { UseMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
export { UseMutateFunction } from './_tsup-dts-rollup.cjs';
export { UseMutationOptions } from './_tsup-dts-rollup.cjs';
export { UseMutationResult } from './_tsup-dts-rollup.cjs';
export { UseQueryOptions } from './_tsup-dts-rollup.cjs';
export { UseQueryResult } from './_tsup-dts-rollup.cjs';
export { CreateBaseQueryOptions } from './_tsup-dts-rollup.cjs';
export { CreateBaseQueryResult } from './_tsup-dts-rollup.cjs';
export { CreateInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { CreateInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
export { CreateMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
export { CreateMutateFunction } from './_tsup-dts-rollup.cjs';
export { CreateMutationOptions } from './_tsup-dts-rollup.cjs';
export { CreateMutationResult } from './_tsup-dts-rollup.cjs';
export { CreateBaseMutationResult } from './_tsup-dts-rollup.cjs';
export { CreateQueryOptions } from './_tsup-dts-rollup.cjs';
export { CreateQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedCreateBaseQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedCreateInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedCreateQueryResult } from './_tsup-dts-rollup.cjs';
export { QueryClient_alias_1 as QueryClient } from './_tsup-dts-rollup.cjs';
export { QueryObserverOptions_alias_1 as QueryObserverOptions } from './_tsup-dts-rollup.cjs';
export { DefaultOptions_alias_1 as DefaultOptions } from './_tsup-dts-rollup.cjs';
export { QueryClientConfig_alias_1 as QueryClientConfig } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverOptions_alias_1 as InfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
export { useQuery } from './_tsup-dts-rollup.cjs';
export { createQuery } from './_tsup-dts-rollup.cjs';
export { queryOptions } from './_tsup-dts-rollup.cjs';
export { DefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.cjs';
export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.cjs';
export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.cjs';
export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.cjs';
export { useIsFetching } from './_tsup-dts-rollup.cjs';
export { createIsFetching } from './_tsup-dts-rollup.cjs';
export { useInfiniteQuery } from './_tsup-dts-rollup.cjs';
export { createInfiniteQuery } from './_tsup-dts-rollup.cjs';
export { infiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
export { useMutation } from './_tsup-dts-rollup.cjs';
export { mutationOptions } from './_tsup-dts-rollup.cjs';
export { createMutation } from './_tsup-dts-rollup.cjs';
export { useIsMutating } from './_tsup-dts-rollup.cjs';
export { createIsMutating } from './_tsup-dts-rollup.cjs';
export { useMutationState } from './_tsup-dts-rollup.cjs';
export { createMutationState } from './_tsup-dts-rollup.cjs';
export { useQueries } from './_tsup-dts-rollup.cjs';
export { createQueries } from './_tsup-dts-rollup.cjs';
export { useIsRestoring } from './_tsup-dts-rollup.cjs';
export { IsRestoringProvider } from './_tsup-dts-rollup.cjs';
export { focusManager } from './_tsup-dts-rollup.cjs';
export { environmentManager } from './_tsup-dts-rollup.cjs';
export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.cjs';
export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.cjs';
export { dehydrate } from './_tsup-dts-rollup.cjs';
export { hydrate } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserver } from './_tsup-dts-rollup.cjs';
export { MutationCache } from './_tsup-dts-rollup.cjs';
export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
export { MutationObserver } from './_tsup-dts-rollup.cjs';
export { defaultScheduler } from './_tsup-dts-rollup.cjs';
export { notifyManager } from './_tsup-dts-rollup.cjs';
export { onlineManager } from './_tsup-dts-rollup.cjs';
export { QueriesObserver } from './_tsup-dts-rollup.cjs';
export { QueryCache } from './_tsup-dts-rollup.cjs';
export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
export { QueryObserver } from './_tsup-dts-rollup.cjs';
export { CancelledError } from './_tsup-dts-rollup.cjs';
export { isCancelledError } from './_tsup-dts-rollup.cjs';
export { timeoutManager } from './_tsup-dts-rollup.cjs';
export { ManagedTimerId } from './_tsup-dts-rollup.cjs';
export { TimeoutCallback } from './_tsup-dts-rollup.cjs';
export { TimeoutProvider } from './_tsup-dts-rollup.cjs';
export { hashKey } from './_tsup-dts-rollup.cjs';
export { isServer } from './_tsup-dts-rollup.cjs';
export { keepPreviousData } from './_tsup-dts-rollup.cjs';
export { matchMutation } from './_tsup-dts-rollup.cjs';
export { matchQuery } from './_tsup-dts-rollup.cjs';
export { noop } from './_tsup-dts-rollup.cjs';
export { partialMatchKey } from './_tsup-dts-rollup.cjs';
export { replaceEqualDeep } from './_tsup-dts-rollup.cjs';
export { shouldThrowError } from './_tsup-dts-rollup.cjs';
export { skipToken } from './_tsup-dts-rollup.cjs';
export { MutationFilters } from './_tsup-dts-rollup.cjs';
export { QueryFilters } from './_tsup-dts-rollup.cjs';
export { SkipToken } from './_tsup-dts-rollup.cjs';
export { Updater } from './_tsup-dts-rollup.cjs';
export { experimental_streamedQuery } from './_tsup-dts-rollup.cjs';
export { DehydratedState } from './_tsup-dts-rollup.cjs';
export { DehydrateOptions } from './_tsup-dts-rollup.cjs';
export { HydrateOptions } from './_tsup-dts-rollup.cjs';
export { Mutation } from './_tsup-dts-rollup.cjs';
export { MutationState } from './_tsup-dts-rollup.cjs';
export { QueriesObserverOptions } from './_tsup-dts-rollup.cjs';
export { Query } from './_tsup-dts-rollup.cjs';
export { QueryState } from './_tsup-dts-rollup.cjs';
export { NonUndefinedGuard } from './_tsup-dts-rollup.cjs';
export { DistributiveOmit } from './_tsup-dts-rollup.cjs';
export { OmitKeyof } from './_tsup-dts-rollup.cjs';
export { Override } from './_tsup-dts-rollup.cjs';
export { NoInfer } from './_tsup-dts-rollup.cjs';
export { Register } from './_tsup-dts-rollup.cjs';
export { DefaultError } from './_tsup-dts-rollup.cjs';
export { QueryKey } from './_tsup-dts-rollup.cjs';
export { dataTagSymbol } from './_tsup-dts-rollup.cjs';
export { dataTagErrorSymbol } from './_tsup-dts-rollup.cjs';
export { unsetMarker } from './_tsup-dts-rollup.cjs';
export { UnsetMarker } from './_tsup-dts-rollup.cjs';
export { AnyDataTag } from './_tsup-dts-rollup.cjs';
export { DataTag } from './_tsup-dts-rollup.cjs';
export { InferDataFromTag } from './_tsup-dts-rollup.cjs';
export { InferErrorFromTag } from './_tsup-dts-rollup.cjs';
export { QueryFunction } from './_tsup-dts-rollup.cjs';
export { StaleTime } from './_tsup-dts-rollup.cjs';
export { StaleTimeFunction } from './_tsup-dts-rollup.cjs';
export { QueryBooleanOption } from './_tsup-dts-rollup.cjs';
export { QueryPersister } from './_tsup-dts-rollup.cjs';
export { QueryFunctionContext } from './_tsup-dts-rollup.cjs';
export { InitialDataFunction } from './_tsup-dts-rollup.cjs';
export { PlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
export { QueryKeyHashFunction } from './_tsup-dts-rollup.cjs';
export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.cjs';
export { GetNextPageParamFunction } from './_tsup-dts-rollup.cjs';
export { InfiniteData } from './_tsup-dts-rollup.cjs';
export { QueryMeta } from './_tsup-dts-rollup.cjs';
export { NetworkMode } from './_tsup-dts-rollup.cjs';
export { NotifyOnChangeProps } from './_tsup-dts-rollup.cjs';
export { QueryOptions } from './_tsup-dts-rollup.cjs';
export { InitialPageParam } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.cjs';
export { ThrowOnError } from './_tsup-dts-rollup.cjs';
export { WithRequired } from './_tsup-dts-rollup.cjs';
export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.cjs';
export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
export { FetchQueryOptions } from './_tsup-dts-rollup.cjs';
export { EnsureQueryDataOptions } from './_tsup-dts-rollup.cjs';
export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.cjs';
export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { ResultOptions } from './_tsup-dts-rollup.cjs';
export { RefetchOptions } from './_tsup-dts-rollup.cjs';
export { InvalidateQueryFilters } from './_tsup-dts-rollup.cjs';
export { RefetchQueryFilters } from './_tsup-dts-rollup.cjs';
export { InvalidateOptions } from './_tsup-dts-rollup.cjs';
export { ResetOptions } from './_tsup-dts-rollup.cjs';
export { FetchNextPageOptions } from './_tsup-dts-rollup.cjs';
export { FetchPreviousPageOptions } from './_tsup-dts-rollup.cjs';
export { QueryStatus } from './_tsup-dts-rollup.cjs';
export { FetchStatus } from './_tsup-dts-rollup.cjs';
export { QueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
export { DefinedQueryObserverResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
export { MutationKey } from './_tsup-dts-rollup.cjs';
export { MutationStatus } from './_tsup-dts-rollup.cjs';
export { MutationScope } from './_tsup-dts-rollup.cjs';
export { MutationMeta } from './_tsup-dts-rollup.cjs';
export { MutationFunctionContext } from './_tsup-dts-rollup.cjs';
export { MutationFunction } from './_tsup-dts-rollup.cjs';
export { MutationOptions } from './_tsup-dts-rollup.cjs';
export { MutationObserverOptions } from './_tsup-dts-rollup.cjs';
export { MutateOptions } from './_tsup-dts-rollup.cjs';
export { MutateFunction } from './_tsup-dts-rollup.cjs';
export { MutationObserverBaseResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverIdleResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverLoadingResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverErrorResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverSuccessResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverResult } from './_tsup-dts-rollup.cjs';
export { CancelOptions } from './_tsup-dts-rollup.cjs';
export { SetDataOptions } from './_tsup-dts-rollup.cjs';
export { NotifyEventType } from './_tsup-dts-rollup.cjs';
export { NotifyEvent } from './_tsup-dts-rollup.cjs';

200
node_modules/@tanstack/solid-query/build/dev.d.ts generated vendored Normal file
View File

@@ -0,0 +1,200 @@
export { DefinedUseBaseQueryResult } from './_tsup-dts-rollup.js';
export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.js';
export { DefinedUseQueryResult } from './_tsup-dts-rollup.js';
export { SolidInfiniteQueryOptions } from './_tsup-dts-rollup.js';
export { SolidMutationOptions } from './_tsup-dts-rollup.js';
export { SolidQueryOptions } from './_tsup-dts-rollup.js';
export { UseBaseMutationResult } from './_tsup-dts-rollup.js';
export { UseBaseQueryOptions } from './_tsup-dts-rollup.js';
export { UseBaseQueryResult } from './_tsup-dts-rollup.js';
export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
export { UseInfiniteQueryResult } from './_tsup-dts-rollup.js';
export { UseMutateAsyncFunction } from './_tsup-dts-rollup.js';
export { UseMutateFunction } from './_tsup-dts-rollup.js';
export { UseMutationOptions } from './_tsup-dts-rollup.js';
export { UseMutationResult } from './_tsup-dts-rollup.js';
export { UseQueryOptions } from './_tsup-dts-rollup.js';
export { UseQueryResult } from './_tsup-dts-rollup.js';
export { CreateBaseQueryOptions } from './_tsup-dts-rollup.js';
export { CreateBaseQueryResult } from './_tsup-dts-rollup.js';
export { CreateInfiniteQueryOptions } from './_tsup-dts-rollup.js';
export { CreateInfiniteQueryResult } from './_tsup-dts-rollup.js';
export { CreateMutateAsyncFunction } from './_tsup-dts-rollup.js';
export { CreateMutateFunction } from './_tsup-dts-rollup.js';
export { CreateMutationOptions } from './_tsup-dts-rollup.js';
export { CreateMutationResult } from './_tsup-dts-rollup.js';
export { CreateBaseMutationResult } from './_tsup-dts-rollup.js';
export { CreateQueryOptions } from './_tsup-dts-rollup.js';
export { CreateQueryResult } from './_tsup-dts-rollup.js';
export { DefinedCreateBaseQueryResult } from './_tsup-dts-rollup.js';
export { DefinedCreateInfiniteQueryResult } from './_tsup-dts-rollup.js';
export { DefinedCreateQueryResult } from './_tsup-dts-rollup.js';
export { QueryClient_alias_1 as QueryClient } from './_tsup-dts-rollup.js';
export { QueryObserverOptions_alias_1 as QueryObserverOptions } from './_tsup-dts-rollup.js';
export { DefaultOptions_alias_1 as DefaultOptions } from './_tsup-dts-rollup.js';
export { QueryClientConfig_alias_1 as QueryClientConfig } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverOptions_alias_1 as InfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
export { useQuery } from './_tsup-dts-rollup.js';
export { createQuery } from './_tsup-dts-rollup.js';
export { queryOptions } from './_tsup-dts-rollup.js';
export { DefinedInitialDataOptions } from './_tsup-dts-rollup.js';
export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.js';
export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.js';
export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.js';
export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.js';
export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.js';
export { useIsFetching } from './_tsup-dts-rollup.js';
export { createIsFetching } from './_tsup-dts-rollup.js';
export { useInfiniteQuery } from './_tsup-dts-rollup.js';
export { createInfiniteQuery } from './_tsup-dts-rollup.js';
export { infiniteQueryOptions } from './_tsup-dts-rollup.js';
export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
export { useMutation } from './_tsup-dts-rollup.js';
export { mutationOptions } from './_tsup-dts-rollup.js';
export { createMutation } from './_tsup-dts-rollup.js';
export { useIsMutating } from './_tsup-dts-rollup.js';
export { createIsMutating } from './_tsup-dts-rollup.js';
export { useMutationState } from './_tsup-dts-rollup.js';
export { createMutationState } from './_tsup-dts-rollup.js';
export { useQueries } from './_tsup-dts-rollup.js';
export { createQueries } from './_tsup-dts-rollup.js';
export { useIsRestoring } from './_tsup-dts-rollup.js';
export { IsRestoringProvider } from './_tsup-dts-rollup.js';
export { focusManager } from './_tsup-dts-rollup.js';
export { environmentManager } from './_tsup-dts-rollup.js';
export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.js';
export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.js';
export { dehydrate } from './_tsup-dts-rollup.js';
export { hydrate } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserver } from './_tsup-dts-rollup.js';
export { MutationCache } from './_tsup-dts-rollup.js';
export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.js';
export { MutationObserver } from './_tsup-dts-rollup.js';
export { defaultScheduler } from './_tsup-dts-rollup.js';
export { notifyManager } from './_tsup-dts-rollup.js';
export { onlineManager } from './_tsup-dts-rollup.js';
export { QueriesObserver } from './_tsup-dts-rollup.js';
export { QueryCache } from './_tsup-dts-rollup.js';
export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.js';
export { QueryObserver } from './_tsup-dts-rollup.js';
export { CancelledError } from './_tsup-dts-rollup.js';
export { isCancelledError } from './_tsup-dts-rollup.js';
export { timeoutManager } from './_tsup-dts-rollup.js';
export { ManagedTimerId } from './_tsup-dts-rollup.js';
export { TimeoutCallback } from './_tsup-dts-rollup.js';
export { TimeoutProvider } from './_tsup-dts-rollup.js';
export { hashKey } from './_tsup-dts-rollup.js';
export { isServer } from './_tsup-dts-rollup.js';
export { keepPreviousData } from './_tsup-dts-rollup.js';
export { matchMutation } from './_tsup-dts-rollup.js';
export { matchQuery } from './_tsup-dts-rollup.js';
export { noop } from './_tsup-dts-rollup.js';
export { partialMatchKey } from './_tsup-dts-rollup.js';
export { replaceEqualDeep } from './_tsup-dts-rollup.js';
export { shouldThrowError } from './_tsup-dts-rollup.js';
export { skipToken } from './_tsup-dts-rollup.js';
export { MutationFilters } from './_tsup-dts-rollup.js';
export { QueryFilters } from './_tsup-dts-rollup.js';
export { SkipToken } from './_tsup-dts-rollup.js';
export { Updater } from './_tsup-dts-rollup.js';
export { experimental_streamedQuery } from './_tsup-dts-rollup.js';
export { DehydratedState } from './_tsup-dts-rollup.js';
export { DehydrateOptions } from './_tsup-dts-rollup.js';
export { HydrateOptions } from './_tsup-dts-rollup.js';
export { Mutation } from './_tsup-dts-rollup.js';
export { MutationState } from './_tsup-dts-rollup.js';
export { QueriesObserverOptions } from './_tsup-dts-rollup.js';
export { Query } from './_tsup-dts-rollup.js';
export { QueryState } from './_tsup-dts-rollup.js';
export { NonUndefinedGuard } from './_tsup-dts-rollup.js';
export { DistributiveOmit } from './_tsup-dts-rollup.js';
export { OmitKeyof } from './_tsup-dts-rollup.js';
export { Override } from './_tsup-dts-rollup.js';
export { NoInfer } from './_tsup-dts-rollup.js';
export { Register } from './_tsup-dts-rollup.js';
export { DefaultError } from './_tsup-dts-rollup.js';
export { QueryKey } from './_tsup-dts-rollup.js';
export { dataTagSymbol } from './_tsup-dts-rollup.js';
export { dataTagErrorSymbol } from './_tsup-dts-rollup.js';
export { unsetMarker } from './_tsup-dts-rollup.js';
export { UnsetMarker } from './_tsup-dts-rollup.js';
export { AnyDataTag } from './_tsup-dts-rollup.js';
export { DataTag } from './_tsup-dts-rollup.js';
export { InferDataFromTag } from './_tsup-dts-rollup.js';
export { InferErrorFromTag } from './_tsup-dts-rollup.js';
export { QueryFunction } from './_tsup-dts-rollup.js';
export { StaleTime } from './_tsup-dts-rollup.js';
export { StaleTimeFunction } from './_tsup-dts-rollup.js';
export { QueryBooleanOption } from './_tsup-dts-rollup.js';
export { QueryPersister } from './_tsup-dts-rollup.js';
export { QueryFunctionContext } from './_tsup-dts-rollup.js';
export { InitialDataFunction } from './_tsup-dts-rollup.js';
export { PlaceholderDataFunction } from './_tsup-dts-rollup.js';
export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.js';
export { QueryKeyHashFunction } from './_tsup-dts-rollup.js';
export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.js';
export { GetNextPageParamFunction } from './_tsup-dts-rollup.js';
export { InfiniteData } from './_tsup-dts-rollup.js';
export { QueryMeta } from './_tsup-dts-rollup.js';
export { NetworkMode } from './_tsup-dts-rollup.js';
export { NotifyOnChangeProps } from './_tsup-dts-rollup.js';
export { QueryOptions } from './_tsup-dts-rollup.js';
export { InitialPageParam } from './_tsup-dts-rollup.js';
export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.js';
export { ThrowOnError } from './_tsup-dts-rollup.js';
export { WithRequired } from './_tsup-dts-rollup.js';
export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.js';
export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
export { FetchQueryOptions } from './_tsup-dts-rollup.js';
export { EnsureQueryDataOptions } from './_tsup-dts-rollup.js';
export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.js';
export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.js';
export { ResultOptions } from './_tsup-dts-rollup.js';
export { RefetchOptions } from './_tsup-dts-rollup.js';
export { InvalidateQueryFilters } from './_tsup-dts-rollup.js';
export { RefetchQueryFilters } from './_tsup-dts-rollup.js';
export { InvalidateOptions } from './_tsup-dts-rollup.js';
export { ResetOptions } from './_tsup-dts-rollup.js';
export { FetchNextPageOptions } from './_tsup-dts-rollup.js';
export { FetchPreviousPageOptions } from './_tsup-dts-rollup.js';
export { QueryStatus } from './_tsup-dts-rollup.js';
export { FetchStatus } from './_tsup-dts-rollup.js';
export { QueryObserverBaseResult } from './_tsup-dts-rollup.js';
export { QueryObserverPendingResult } from './_tsup-dts-rollup.js';
export { QueryObserverLoadingResult } from './_tsup-dts-rollup.js';
export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
export { QueryObserverSuccessResult } from './_tsup-dts-rollup.js';
export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
export { DefinedQueryObserverResult } from './_tsup-dts-rollup.js';
export { QueryObserverResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
export { MutationKey } from './_tsup-dts-rollup.js';
export { MutationStatus } from './_tsup-dts-rollup.js';
export { MutationScope } from './_tsup-dts-rollup.js';
export { MutationMeta } from './_tsup-dts-rollup.js';
export { MutationFunctionContext } from './_tsup-dts-rollup.js';
export { MutationFunction } from './_tsup-dts-rollup.js';
export { MutationOptions } from './_tsup-dts-rollup.js';
export { MutationObserverOptions } from './_tsup-dts-rollup.js';
export { MutateOptions } from './_tsup-dts-rollup.js';
export { MutateFunction } from './_tsup-dts-rollup.js';
export { MutationObserverBaseResult } from './_tsup-dts-rollup.js';
export { MutationObserverIdleResult } from './_tsup-dts-rollup.js';
export { MutationObserverLoadingResult } from './_tsup-dts-rollup.js';
export { MutationObserverErrorResult } from './_tsup-dts-rollup.js';
export { MutationObserverSuccessResult } from './_tsup-dts-rollup.js';
export { MutationObserverResult } from './_tsup-dts-rollup.js';
export { CancelOptions } from './_tsup-dts-rollup.js';
export { SetDataOptions } from './_tsup-dts-rollup.js';
export { NotifyEventType } from './_tsup-dts-rollup.js';
export { NotifyEvent } from './_tsup-dts-rollup.js';

530
node_modules/@tanstack/solid-query/build/dev.js generated vendored Normal file
View File

@@ -0,0 +1,530 @@
import { MutationObserver, shouldThrowError, QueriesObserver, noop, QueryClient as QueryClient$1, replaceEqualDeep, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
export * from '@tanstack/query-core';
import { createContext, useContext, createRenderEffect, onCleanup, createMemo, createComputed, on, mergeProps, createResource, batch, onMount, createSignal, createEffect } from 'solid-js';
import { createComponent, isServer } from 'solid-js/web';
import { createStore, unwrap, reconcile } from 'solid-js/store';
// src/useQuery.ts
var QueryClientContext = createContext(void 0);
var useQueryClient = (queryClient) => {
if (queryClient) {
return queryClient;
}
const client = useContext(QueryClientContext);
if (!client) {
throw new Error("No QueryClient set, use QueryClientProvider to set one");
}
return client();
};
var QueryClientProvider = (props) => {
createRenderEffect((unmount) => {
unmount?.();
props.client.mount();
return props.client.unmount.bind(props.client);
});
onCleanup(() => props.client.unmount());
return createComponent(QueryClientContext.Provider, {
value: () => props.client,
get children() {
return props.children;
}
});
};
var IsRestoringContext = createContext(() => false);
var useIsRestoring = () => useContext(IsRestoringContext);
var IsRestoringProvider = IsRestoringContext.Provider;
// src/useBaseQuery.ts
function reconcileFn(store, result, reconcileOption, queryHash) {
if (reconcileOption === false) return result;
if (typeof reconcileOption === "function") {
const newData2 = reconcileOption(store.data, result.data);
return { ...result, data: newData2 };
}
let data = result.data;
if (store.data === void 0) {
try {
data = structuredClone(data);
} catch (error) {
{
if (error instanceof Error) {
console.warn(
`Unable to correctly reconcile data for query key: ${queryHash}. Possibly because the query data contains data structures that aren't supported by the 'structuredClone' algorithm. Consider using a callback function instead to manage the reconciliation manually.
Error Received: ${error.name} - ${error.message}`
);
}
}
}
}
const newData = reconcile(data, { key: reconcileOption })(store.data);
return { ...result, data: newData };
}
var hydratableObserverResult = (query, result) => {
if (!isServer) return result;
const obj = {
...unwrap(result),
// During SSR, functions cannot be serialized, so we need to remove them
// This is safe because we will add these functions back when the query is hydrated
refetch: void 0
};
if ("fetchNextPage" in result) {
obj.fetchNextPage = void 0;
obj.fetchPreviousPage = void 0;
}
obj.hydrationData = {
state: query.state,
queryKey: query.queryKey,
queryHash: query.queryHash,
...query.meta && { meta: query.meta }
};
return obj;
};
function useBaseQuery(options, Observer, queryClient) {
const client = createMemo(() => useQueryClient(queryClient?.()));
const isRestoring = useIsRestoring();
let unsubscribeQueued = false;
const defaultedOptions = createMemo(() => {
const defaultOptions = client().defaultQueryOptions(options());
defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
defaultOptions.structuralSharing = false;
if (isServer) {
defaultOptions.retry = false;
defaultOptions.throwOnError = true;
defaultOptions.experimental_prefetchInRender = true;
}
return defaultOptions;
});
const initialOptions = defaultedOptions();
const [observer, setObserver] = createSignal(
new Observer(client(), defaultedOptions())
);
let observerResult = observer().getOptimisticResult(defaultedOptions());
const [state, setState] = createStore(observerResult);
const createServerSubscriber = (resolve, reject) => {
return observer().subscribe((result) => {
notifyManager.batchCalls(() => {
const query = observer().getCurrentQuery();
const unwrappedResult = hydratableObserverResult(query, result);
if (result.data !== void 0 && unwrappedResult.isError) {
reject(unwrappedResult.error);
unsubscribeIfQueued();
} else {
resolve(unwrappedResult);
unsubscribeIfQueued();
}
})();
});
};
const unsubscribeIfQueued = () => {
if (unsubscribeQueued) {
unsubscribe?.();
unsubscribeQueued = false;
}
};
const createClientSubscriber = () => {
const obs = observer();
return obs.subscribe((result) => {
observerResult = result;
queueMicrotask(() => {
if (unsubscribe) {
refetch();
}
});
});
};
function setStateWithReconciliation(res) {
const opts = observer().options;
const reconcileOptions = opts.reconcile;
setState((store) => {
return reconcileFn(
store,
res,
reconcileOptions === void 0 ? false : reconcileOptions,
opts.queryHash
);
});
}
function createDeepSignal() {
return [
() => state,
(v) => {
const unwrapped = unwrap(state);
if (typeof v === "function") {
v = v(unwrapped);
}
if (v?.hydrationData) {
const { hydrationData, ...rest } = v;
v = rest;
}
setStateWithReconciliation(v);
}
];
}
let unsubscribe = null;
let resolver = null;
const [queryResource, { refetch }] = createResource(
() => {
const obs = observer();
return new Promise((resolve, reject) => {
resolver = resolve;
if (isServer) {
unsubscribe = createServerSubscriber(resolve, reject);
} else if (!unsubscribe && !isRestoring()) {
unsubscribe = createClientSubscriber();
}
obs.updateResult();
if (observerResult.isError && !observerResult.isFetching && !isRestoring() && shouldThrowError(obs.options.throwOnError, [
observerResult.error,
obs.getCurrentQuery()
])) {
setStateWithReconciliation(observerResult);
return reject(observerResult.error);
}
if (!observerResult.isLoading) {
resolver = null;
return resolve(
hydratableObserverResult(obs.getCurrentQuery(), observerResult)
);
}
setStateWithReconciliation(observerResult);
});
},
{
storage: createDeepSignal,
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 && "hydrationData" in info.value) {
hydrate(client(), {
// @ts-expect-error - hydrationData is not correctly typed internally
queries: [{ ...info.value.hydrationData }]
});
}
if (unsubscribe) return;
const newOptions = { ...initialOptions };
if ((initialOptions.staleTime || !initialOptions.initialData) && info.value) {
newOptions.refetchOnMount = false;
}
observer().setOptions(newOptions);
setStateWithReconciliation(observer().getOptimisticResult(newOptions));
unsubscribe = createClientSubscriber();
}
}
);
createComputed(
on(
client,
(c) => {
if (unsubscribe) {
unsubscribe();
}
const newObserver = new Observer(c, defaultedOptions());
unsubscribe = createClientSubscriber();
setObserver(newObserver);
},
{
defer: true
}
)
);
createComputed(
on(
isRestoring,
(restoring) => {
if (!restoring && !isServer) {
refetch();
}
},
{ defer: true }
)
);
onCleanup(() => {
if (isServer && queryResource.loading) {
unsubscribeQueued = true;
return;
}
if (unsubscribe) {
unsubscribe();
unsubscribe = null;
}
if (resolver && !isServer) {
resolver(observerResult);
resolver = null;
}
});
createComputed(
on(
[observer, defaultedOptions],
([obs, opts]) => {
obs.setOptions(opts);
setStateWithReconciliation(obs.getOptimisticResult(opts));
refetch();
},
{ defer: true }
)
);
const handler = {
get(target, prop) {
if (prop === "data") {
if (state.data !== void 0) {
return queryResource.latest?.data;
}
return queryResource()?.data;
}
return Reflect.get(target, prop);
}
};
return new Proxy(state, handler);
}
// src/useQuery.ts
function useQuery(options, queryClient) {
return useBaseQuery(
createMemo(() => options()),
QueryObserver,
queryClient
);
}
function useInfiniteQuery(options, queryClient) {
return useBaseQuery(
createMemo(() => options()),
InfiniteQueryObserver,
queryClient
);
}
function useMutation(options, queryClient) {
const client = createMemo(() => 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;
}
function useQueries(queriesOptions, queryClient) {
const client = createMemo(() => useQueryClient(queryClient?.()));
const isRestoring = useIsRestoring();
const defaultedQueries = createMemo(
() => queriesOptions().queries.map(
(options) => mergeProps(
client().defaultQueryOptions(options),
{
get _optimisticResults() {
return isRestoring() ? "isRestoring" : "optimistic";
}
}
)
)
);
const observer = new QueriesObserver(
client(),
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
const [state, setState] = createStore(
observer.getOptimisticResult(
defaultedQueries(),
queriesOptions().combine
)[1]()
);
createRenderEffect(
on(
() => queriesOptions().queries.length,
() => setState(
observer.getOptimisticResult(
defaultedQueries(),
queriesOptions().combine
)[1]()
)
)
);
const dataResources = createMemo(
on(
() => state.length,
() => state.map((queryRes) => {
const dataPromise = () => new Promise((resolve) => {
if (queryRes.isFetching && queryRes.isLoading) return;
resolve(unwrap(queryRes.data));
});
return createResource(dataPromise);
})
)
);
batch(() => {
const dataResources_ = dataResources();
for (let index = 0; index < dataResources_.length; index++) {
const dataResource = dataResources_[index];
dataResource[1].mutate(() => unwrap(state[index].data));
dataResource[1].refetch();
}
});
let taskQueue = [];
const subscribeToObserver = () => observer.subscribe((result) => {
taskQueue.push(() => {
batch(() => {
const dataResources_ = dataResources();
for (let index = 0; index < dataResources_.length; index++) {
const dataResource = dataResources_[index];
const unwrappedResult = { ...unwrap(result[index]) };
setState(index, unwrap(unwrappedResult));
dataResource[1].mutate(() => unwrap(state[index].data));
dataResource[1].refetch();
}
});
});
queueMicrotask(() => {
const taskToRun = taskQueue.pop();
if (taskToRun) taskToRun();
taskQueue = [];
});
});
let unsubscribe = noop;
createComputed((cleanup) => {
cleanup?.();
unsubscribe = isRestoring() ? noop : subscribeToObserver();
return () => queueMicrotask(unsubscribe);
});
onCleanup(unsubscribe);
onMount(() => {
observer.setQueries(
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
});
createComputed(() => {
observer.setQueries(
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
});
const handler = (index) => ({
get(target, prop) {
if (prop === "data") {
return dataResources()[index][0]();
}
return Reflect.get(target, prop);
}
});
const getProxies = () => state.map((s, index) => {
return new Proxy(s, handler(index));
});
const [proxyState, setProxyState] = createStore(getProxies());
createRenderEffect(() => setProxyState(getProxies()));
return proxyState;
}
var QueryClient = class extends QueryClient$1 {
constructor(config = {}) {
super(config);
}
};
// src/queryOptions.ts
function queryOptions(options) {
return options;
}
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;
}
// src/infiniteQueryOptions.ts
function infiniteQueryOptions(options) {
return options;
}
// src/mutationOptions.ts
function mutationOptions(options) {
return options;
}
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;
}
function getResult(mutationCache, options) {
return mutationCache.findAll(options.filters).map(
(mutation) => options.select ? options.select(mutation) : mutation.state
);
}
function useMutationState(options = () => ({}), queryClient) {
const client = createMemo(() => useQueryClient(queryClient?.()));
const mutationCache = createMemo(() => client().getMutationCache());
const [result, setResult] = createSignal(
getResult(mutationCache(), options())
);
createEffect(() => {
const unsubscribe = mutationCache().subscribe(() => {
const nextResult = replaceEqualDeep(
result(),
getResult(mutationCache(), options())
);
if (result() !== nextResult) {
setResult(nextResult);
}
});
onCleanup(unsubscribe);
});
return result;
}
// src/index.ts
var createQuery = useQuery;
var createInfiniteQuery = useInfiniteQuery;
var createMutation = useMutation;
var createQueries = useQueries;
export { IsRestoringProvider, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, useIsFetching as createIsFetching, useIsMutating as createIsMutating, createMutation, useMutationState as createMutationState, createQueries, createQuery, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };

540
node_modules/@tanstack/solid-query/build/index.cjs generated vendored Normal file
View File

@@ -0,0 +1,540 @@
'use strict';
var queryCore = require('@tanstack/query-core');
var solidJs = require('solid-js');
var web = require('solid-js/web');
var store = require('solid-js/store');
// src/useQuery.ts
exports.QueryClientContext = solidJs.createContext(void 0);
exports.useQueryClient = (queryClient) => {
if (queryClient) {
return queryClient;
}
const client = solidJs.useContext(exports.QueryClientContext);
if (!client) {
throw new Error("No QueryClient set, use QueryClientProvider to set one");
}
return client();
};
exports.QueryClientProvider = (props) => {
solidJs.createRenderEffect((unmount) => {
unmount?.();
props.client.mount();
return props.client.unmount.bind(props.client);
});
solidJs.onCleanup(() => props.client.unmount());
return web.createComponent(exports.QueryClientContext.Provider, {
value: () => props.client,
get children() {
return props.children;
}
});
};
var IsRestoringContext = solidJs.createContext(() => false);
exports.useIsRestoring = () => solidJs.useContext(IsRestoringContext);
exports.IsRestoringProvider = IsRestoringContext.Provider;
// src/useBaseQuery.ts
function reconcileFn(store$1, result, reconcileOption, queryHash) {
if (reconcileOption === false) return result;
if (typeof reconcileOption === "function") {
const newData2 = reconcileOption(store$1.data, result.data);
return { ...result, data: newData2 };
}
let data = result.data;
if (store$1.data === void 0) {
try {
data = structuredClone(data);
} catch (error) {
}
}
const newData = store.reconcile(data, { key: reconcileOption })(store$1.data);
return { ...result, data: newData };
}
var hydratableObserverResult = (query, result) => {
if (!web.isServer) return result;
const obj = {
...store.unwrap(result),
// During SSR, functions cannot be serialized, so we need to remove them
// This is safe because we will add these functions back when the query is hydrated
refetch: void 0
};
if ("fetchNextPage" in result) {
obj.fetchNextPage = void 0;
obj.fetchPreviousPage = void 0;
}
obj.hydrationData = {
state: query.state,
queryKey: query.queryKey,
queryHash: query.queryHash,
...query.meta && { meta: query.meta }
};
return obj;
};
function useBaseQuery(options, Observer, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const isRestoring = exports.useIsRestoring();
let unsubscribeQueued = false;
const defaultedOptions = solidJs.createMemo(() => {
const defaultOptions = client().defaultQueryOptions(options());
defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
defaultOptions.structuralSharing = false;
if (web.isServer) {
defaultOptions.retry = false;
defaultOptions.throwOnError = true;
defaultOptions.experimental_prefetchInRender = true;
}
return defaultOptions;
});
const initialOptions = defaultedOptions();
const [observer, setObserver] = solidJs.createSignal(
new Observer(client(), defaultedOptions())
);
let observerResult = observer().getOptimisticResult(defaultedOptions());
const [state, setState] = store.createStore(observerResult);
const createServerSubscriber = (resolve, reject) => {
return observer().subscribe((result) => {
queryCore.notifyManager.batchCalls(() => {
const query = observer().getCurrentQuery();
const unwrappedResult = hydratableObserverResult(query, result);
if (result.data !== void 0 && unwrappedResult.isError) {
reject(unwrappedResult.error);
unsubscribeIfQueued();
} else {
resolve(unwrappedResult);
unsubscribeIfQueued();
}
})();
});
};
const unsubscribeIfQueued = () => {
if (unsubscribeQueued) {
unsubscribe?.();
unsubscribeQueued = false;
}
};
const createClientSubscriber = () => {
const obs = observer();
return obs.subscribe((result) => {
observerResult = result;
queueMicrotask(() => {
if (unsubscribe) {
refetch();
}
});
});
};
function setStateWithReconciliation(res) {
const opts = observer().options;
const reconcileOptions = opts.reconcile;
setState((store) => {
return reconcileFn(
store,
res,
reconcileOptions === void 0 ? false : reconcileOptions,
opts.queryHash
);
});
}
function createDeepSignal() {
return [
() => state,
(v) => {
const unwrapped = store.unwrap(state);
if (typeof v === "function") {
v = v(unwrapped);
}
if (v?.hydrationData) {
const { hydrationData, ...rest } = v;
v = rest;
}
setStateWithReconciliation(v);
}
];
}
let unsubscribe = null;
let resolver = null;
const [queryResource, { refetch }] = solidJs.createResource(
() => {
const obs = observer();
return new Promise((resolve, reject) => {
resolver = resolve;
if (web.isServer) {
unsubscribe = createServerSubscriber(resolve, reject);
} else if (!unsubscribe && !isRestoring()) {
unsubscribe = createClientSubscriber();
}
obs.updateResult();
if (observerResult.isError && !observerResult.isFetching && !isRestoring() && queryCore.shouldThrowError(obs.options.throwOnError, [
observerResult.error,
obs.getCurrentQuery()
])) {
setStateWithReconciliation(observerResult);
return reject(observerResult.error);
}
if (!observerResult.isLoading) {
resolver = null;
return resolve(
hydratableObserverResult(obs.getCurrentQuery(), observerResult)
);
}
setStateWithReconciliation(observerResult);
});
},
{
storage: createDeepSignal,
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 && "hydrationData" in info.value) {
queryCore.hydrate(client(), {
// @ts-expect-error - hydrationData is not correctly typed internally
queries: [{ ...info.value.hydrationData }]
});
}
if (unsubscribe) return;
const newOptions = { ...initialOptions };
if ((initialOptions.staleTime || !initialOptions.initialData) && info.value) {
newOptions.refetchOnMount = false;
}
observer().setOptions(newOptions);
setStateWithReconciliation(observer().getOptimisticResult(newOptions));
unsubscribe = createClientSubscriber();
}
}
);
solidJs.createComputed(
solidJs.on(
client,
(c) => {
if (unsubscribe) {
unsubscribe();
}
const newObserver = new Observer(c, defaultedOptions());
unsubscribe = createClientSubscriber();
setObserver(newObserver);
},
{
defer: true
}
)
);
solidJs.createComputed(
solidJs.on(
isRestoring,
(restoring) => {
if (!restoring && !web.isServer) {
refetch();
}
},
{ defer: true }
)
);
solidJs.onCleanup(() => {
if (web.isServer && queryResource.loading) {
unsubscribeQueued = true;
return;
}
if (unsubscribe) {
unsubscribe();
unsubscribe = null;
}
if (resolver && !web.isServer) {
resolver(observerResult);
resolver = null;
}
});
solidJs.createComputed(
solidJs.on(
[observer, defaultedOptions],
([obs, opts]) => {
obs.setOptions(opts);
setStateWithReconciliation(obs.getOptimisticResult(opts));
refetch();
},
{ defer: true }
)
);
const handler = {
get(target, prop) {
if (prop === "data") {
if (state.data !== void 0) {
return queryResource.latest?.data;
}
return queryResource()?.data;
}
return Reflect.get(target, prop);
}
};
return new Proxy(state, handler);
}
// src/useQuery.ts
function useQuery(options, queryClient) {
return useBaseQuery(
solidJs.createMemo(() => options()),
queryCore.QueryObserver,
queryClient
);
}
function useInfiniteQuery(options, queryClient) {
return useBaseQuery(
solidJs.createMemo(() => options()),
queryCore.InfiniteQueryObserver,
queryClient
);
}
function useMutation(options, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const observer = new queryCore.MutationObserver(client(), options());
const mutate = (variables, mutateOptions) => {
observer.mutate(variables, mutateOptions).catch(queryCore.noop);
};
const [state, setState] = store.createStore({
...observer.getCurrentResult(),
mutate,
mutateAsync: observer.getCurrentResult().mutate
});
solidJs.createComputed(() => {
observer.setOptions(options());
});
solidJs.createComputed(
solidJs.on(
() => state.status,
() => {
if (state.isError && queryCore.shouldThrowError(observer.options.throwOnError, [state.error])) {
throw state.error;
}
}
)
);
const unsubscribe = observer.subscribe((result) => {
setState({
...result,
mutate,
mutateAsync: result.mutate
});
});
solidJs.onCleanup(unsubscribe);
return state;
}
function useQueries(queriesOptions, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const isRestoring = exports.useIsRestoring();
const defaultedQueries = solidJs.createMemo(
() => queriesOptions().queries.map(
(options) => solidJs.mergeProps(
client().defaultQueryOptions(options),
{
get _optimisticResults() {
return isRestoring() ? "isRestoring" : "optimistic";
}
}
)
)
);
const observer = new queryCore.QueriesObserver(
client(),
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
const [state, setState] = store.createStore(
observer.getOptimisticResult(
defaultedQueries(),
queriesOptions().combine
)[1]()
);
solidJs.createRenderEffect(
solidJs.on(
() => queriesOptions().queries.length,
() => setState(
observer.getOptimisticResult(
defaultedQueries(),
queriesOptions().combine
)[1]()
)
)
);
const dataResources = solidJs.createMemo(
solidJs.on(
() => state.length,
() => state.map((queryRes) => {
const dataPromise = () => new Promise((resolve) => {
if (queryRes.isFetching && queryRes.isLoading) return;
resolve(store.unwrap(queryRes.data));
});
return solidJs.createResource(dataPromise);
})
)
);
solidJs.batch(() => {
const dataResources_ = dataResources();
for (let index = 0; index < dataResources_.length; index++) {
const dataResource = dataResources_[index];
dataResource[1].mutate(() => store.unwrap(state[index].data));
dataResource[1].refetch();
}
});
let taskQueue = [];
const subscribeToObserver = () => observer.subscribe((result) => {
taskQueue.push(() => {
solidJs.batch(() => {
const dataResources_ = dataResources();
for (let index = 0; index < dataResources_.length; index++) {
const dataResource = dataResources_[index];
const unwrappedResult = { ...store.unwrap(result[index]) };
setState(index, store.unwrap(unwrappedResult));
dataResource[1].mutate(() => store.unwrap(state[index].data));
dataResource[1].refetch();
}
});
});
queueMicrotask(() => {
const taskToRun = taskQueue.pop();
if (taskToRun) taskToRun();
taskQueue = [];
});
});
let unsubscribe = queryCore.noop;
solidJs.createComputed((cleanup) => {
cleanup?.();
unsubscribe = isRestoring() ? queryCore.noop : subscribeToObserver();
return () => queueMicrotask(unsubscribe);
});
solidJs.onCleanup(unsubscribe);
solidJs.onMount(() => {
observer.setQueries(
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
});
solidJs.createComputed(() => {
observer.setQueries(
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
});
const handler = (index) => ({
get(target, prop) {
if (prop === "data") {
return dataResources()[index][0]();
}
return Reflect.get(target, prop);
}
});
const getProxies = () => state.map((s, index) => {
return new Proxy(s, handler(index));
});
const [proxyState, setProxyState] = store.createStore(getProxies());
solidJs.createRenderEffect(() => setProxyState(getProxies()));
return proxyState;
}
exports.QueryClient = class QueryClient extends queryCore.QueryClient {
constructor(config = {}) {
super(config);
}
};
// src/queryOptions.ts
function queryOptions(options) {
return options;
}
function useIsFetching(filters, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const queryCache = solidJs.createMemo(() => client().getQueryCache());
const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
const unsubscribe = queryCache().subscribe(() => {
setFetches(client().isFetching(filters?.()));
});
solidJs.onCleanup(unsubscribe);
return fetches;
}
// src/infiniteQueryOptions.ts
function infiniteQueryOptions(options) {
return options;
}
// src/mutationOptions.ts
function mutationOptions(options) {
return options;
}
function useIsMutating(filters, queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const mutationCache = solidJs.createMemo(() => client().getMutationCache());
const [mutations, setMutations] = solidJs.createSignal(
client().isMutating(filters?.())
);
const unsubscribe = mutationCache().subscribe((_result) => {
setMutations(client().isMutating(filters?.()));
});
solidJs.onCleanup(unsubscribe);
return mutations;
}
function getResult(mutationCache, options) {
return mutationCache.findAll(options.filters).map(
(mutation) => options.select ? options.select(mutation) : mutation.state
);
}
function useMutationState(options = () => ({}), queryClient) {
const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
const mutationCache = solidJs.createMemo(() => client().getMutationCache());
const [result, setResult] = solidJs.createSignal(
getResult(mutationCache(), options())
);
solidJs.createEffect(() => {
const unsubscribe = mutationCache().subscribe(() => {
const nextResult = queryCore.replaceEqualDeep(
result(),
getResult(mutationCache(), options())
);
if (result() !== nextResult) {
setResult(nextResult);
}
});
solidJs.onCleanup(unsubscribe);
});
return result;
}
// src/index.ts
exports.createQuery = useQuery;
exports.createInfiniteQuery = useInfiniteQuery;
exports.createMutation = useMutation;
exports.createQueries = useQueries;
exports.createIsFetching = useIsFetching;
exports.createIsMutating = useIsMutating;
exports.createMutationState = useMutationState;
exports.infiniteQueryOptions = infiniteQueryOptions;
exports.mutationOptions = mutationOptions;
exports.queryOptions = queryOptions;
exports.useInfiniteQuery = useInfiniteQuery;
exports.useIsFetching = useIsFetching;
exports.useIsMutating = useIsMutating;
exports.useMutation = useMutation;
exports.useMutationState = useMutationState;
exports.useQueries = useQueries;
exports.useQuery = useQuery;
Object.keys(queryCore).forEach(function (k) {
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
enumerable: true,
get: function () { return queryCore[k]; }
});
});

200
node_modules/@tanstack/solid-query/build/index.d.cts generated vendored Normal file
View File

@@ -0,0 +1,200 @@
export { DefinedUseBaseQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedUseQueryResult } from './_tsup-dts-rollup.cjs';
export { SolidInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { SolidMutationOptions } from './_tsup-dts-rollup.cjs';
export { SolidQueryOptions } from './_tsup-dts-rollup.cjs';
export { UseBaseMutationResult } from './_tsup-dts-rollup.cjs';
export { UseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
export { UseBaseQueryResult } from './_tsup-dts-rollup.cjs';
export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { UseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
export { UseMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
export { UseMutateFunction } from './_tsup-dts-rollup.cjs';
export { UseMutationOptions } from './_tsup-dts-rollup.cjs';
export { UseMutationResult } from './_tsup-dts-rollup.cjs';
export { UseQueryOptions } from './_tsup-dts-rollup.cjs';
export { UseQueryResult } from './_tsup-dts-rollup.cjs';
export { CreateBaseQueryOptions } from './_tsup-dts-rollup.cjs';
export { CreateBaseQueryResult } from './_tsup-dts-rollup.cjs';
export { CreateInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { CreateInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
export { CreateMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
export { CreateMutateFunction } from './_tsup-dts-rollup.cjs';
export { CreateMutationOptions } from './_tsup-dts-rollup.cjs';
export { CreateMutationResult } from './_tsup-dts-rollup.cjs';
export { CreateBaseMutationResult } from './_tsup-dts-rollup.cjs';
export { CreateQueryOptions } from './_tsup-dts-rollup.cjs';
export { CreateQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedCreateBaseQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedCreateInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
export { DefinedCreateQueryResult } from './_tsup-dts-rollup.cjs';
export { QueryClient_alias_1 as QueryClient } from './_tsup-dts-rollup.cjs';
export { QueryObserverOptions_alias_1 as QueryObserverOptions } from './_tsup-dts-rollup.cjs';
export { DefaultOptions_alias_1 as DefaultOptions } from './_tsup-dts-rollup.cjs';
export { QueryClientConfig_alias_1 as QueryClientConfig } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverOptions_alias_1 as InfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
export { useQuery } from './_tsup-dts-rollup.cjs';
export { createQuery } from './_tsup-dts-rollup.cjs';
export { queryOptions } from './_tsup-dts-rollup.cjs';
export { DefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.cjs';
export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.cjs';
export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.cjs';
export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.cjs';
export { useIsFetching } from './_tsup-dts-rollup.cjs';
export { createIsFetching } from './_tsup-dts-rollup.cjs';
export { useInfiniteQuery } from './_tsup-dts-rollup.cjs';
export { createInfiniteQuery } from './_tsup-dts-rollup.cjs';
export { infiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
export { useMutation } from './_tsup-dts-rollup.cjs';
export { mutationOptions } from './_tsup-dts-rollup.cjs';
export { createMutation } from './_tsup-dts-rollup.cjs';
export { useIsMutating } from './_tsup-dts-rollup.cjs';
export { createIsMutating } from './_tsup-dts-rollup.cjs';
export { useMutationState } from './_tsup-dts-rollup.cjs';
export { createMutationState } from './_tsup-dts-rollup.cjs';
export { useQueries } from './_tsup-dts-rollup.cjs';
export { createQueries } from './_tsup-dts-rollup.cjs';
export { useIsRestoring } from './_tsup-dts-rollup.cjs';
export { IsRestoringProvider } from './_tsup-dts-rollup.cjs';
export { focusManager } from './_tsup-dts-rollup.cjs';
export { environmentManager } from './_tsup-dts-rollup.cjs';
export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.cjs';
export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.cjs';
export { dehydrate } from './_tsup-dts-rollup.cjs';
export { hydrate } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserver } from './_tsup-dts-rollup.cjs';
export { MutationCache } from './_tsup-dts-rollup.cjs';
export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
export { MutationObserver } from './_tsup-dts-rollup.cjs';
export { defaultScheduler } from './_tsup-dts-rollup.cjs';
export { notifyManager } from './_tsup-dts-rollup.cjs';
export { onlineManager } from './_tsup-dts-rollup.cjs';
export { QueriesObserver } from './_tsup-dts-rollup.cjs';
export { QueryCache } from './_tsup-dts-rollup.cjs';
export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
export { QueryObserver } from './_tsup-dts-rollup.cjs';
export { CancelledError } from './_tsup-dts-rollup.cjs';
export { isCancelledError } from './_tsup-dts-rollup.cjs';
export { timeoutManager } from './_tsup-dts-rollup.cjs';
export { ManagedTimerId } from './_tsup-dts-rollup.cjs';
export { TimeoutCallback } from './_tsup-dts-rollup.cjs';
export { TimeoutProvider } from './_tsup-dts-rollup.cjs';
export { hashKey } from './_tsup-dts-rollup.cjs';
export { isServer } from './_tsup-dts-rollup.cjs';
export { keepPreviousData } from './_tsup-dts-rollup.cjs';
export { matchMutation } from './_tsup-dts-rollup.cjs';
export { matchQuery } from './_tsup-dts-rollup.cjs';
export { noop } from './_tsup-dts-rollup.cjs';
export { partialMatchKey } from './_tsup-dts-rollup.cjs';
export { replaceEqualDeep } from './_tsup-dts-rollup.cjs';
export { shouldThrowError } from './_tsup-dts-rollup.cjs';
export { skipToken } from './_tsup-dts-rollup.cjs';
export { MutationFilters } from './_tsup-dts-rollup.cjs';
export { QueryFilters } from './_tsup-dts-rollup.cjs';
export { SkipToken } from './_tsup-dts-rollup.cjs';
export { Updater } from './_tsup-dts-rollup.cjs';
export { experimental_streamedQuery } from './_tsup-dts-rollup.cjs';
export { DehydratedState } from './_tsup-dts-rollup.cjs';
export { DehydrateOptions } from './_tsup-dts-rollup.cjs';
export { HydrateOptions } from './_tsup-dts-rollup.cjs';
export { Mutation } from './_tsup-dts-rollup.cjs';
export { MutationState } from './_tsup-dts-rollup.cjs';
export { QueriesObserverOptions } from './_tsup-dts-rollup.cjs';
export { Query } from './_tsup-dts-rollup.cjs';
export { QueryState } from './_tsup-dts-rollup.cjs';
export { NonUndefinedGuard } from './_tsup-dts-rollup.cjs';
export { DistributiveOmit } from './_tsup-dts-rollup.cjs';
export { OmitKeyof } from './_tsup-dts-rollup.cjs';
export { Override } from './_tsup-dts-rollup.cjs';
export { NoInfer } from './_tsup-dts-rollup.cjs';
export { Register } from './_tsup-dts-rollup.cjs';
export { DefaultError } from './_tsup-dts-rollup.cjs';
export { QueryKey } from './_tsup-dts-rollup.cjs';
export { dataTagSymbol } from './_tsup-dts-rollup.cjs';
export { dataTagErrorSymbol } from './_tsup-dts-rollup.cjs';
export { unsetMarker } from './_tsup-dts-rollup.cjs';
export { UnsetMarker } from './_tsup-dts-rollup.cjs';
export { AnyDataTag } from './_tsup-dts-rollup.cjs';
export { DataTag } from './_tsup-dts-rollup.cjs';
export { InferDataFromTag } from './_tsup-dts-rollup.cjs';
export { InferErrorFromTag } from './_tsup-dts-rollup.cjs';
export { QueryFunction } from './_tsup-dts-rollup.cjs';
export { StaleTime } from './_tsup-dts-rollup.cjs';
export { StaleTimeFunction } from './_tsup-dts-rollup.cjs';
export { QueryBooleanOption } from './_tsup-dts-rollup.cjs';
export { QueryPersister } from './_tsup-dts-rollup.cjs';
export { QueryFunctionContext } from './_tsup-dts-rollup.cjs';
export { InitialDataFunction } from './_tsup-dts-rollup.cjs';
export { PlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
export { QueryKeyHashFunction } from './_tsup-dts-rollup.cjs';
export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.cjs';
export { GetNextPageParamFunction } from './_tsup-dts-rollup.cjs';
export { InfiniteData } from './_tsup-dts-rollup.cjs';
export { QueryMeta } from './_tsup-dts-rollup.cjs';
export { NetworkMode } from './_tsup-dts-rollup.cjs';
export { NotifyOnChangeProps } from './_tsup-dts-rollup.cjs';
export { QueryOptions } from './_tsup-dts-rollup.cjs';
export { InitialPageParam } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.cjs';
export { ThrowOnError } from './_tsup-dts-rollup.cjs';
export { WithRequired } from './_tsup-dts-rollup.cjs';
export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.cjs';
export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
export { FetchQueryOptions } from './_tsup-dts-rollup.cjs';
export { EnsureQueryDataOptions } from './_tsup-dts-rollup.cjs';
export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.cjs';
export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
export { ResultOptions } from './_tsup-dts-rollup.cjs';
export { RefetchOptions } from './_tsup-dts-rollup.cjs';
export { InvalidateQueryFilters } from './_tsup-dts-rollup.cjs';
export { RefetchQueryFilters } from './_tsup-dts-rollup.cjs';
export { InvalidateOptions } from './_tsup-dts-rollup.cjs';
export { ResetOptions } from './_tsup-dts-rollup.cjs';
export { FetchNextPageOptions } from './_tsup-dts-rollup.cjs';
export { FetchPreviousPageOptions } from './_tsup-dts-rollup.cjs';
export { QueryStatus } from './_tsup-dts-rollup.cjs';
export { FetchStatus } from './_tsup-dts-rollup.cjs';
export { QueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
export { DefinedQueryObserverResult } from './_tsup-dts-rollup.cjs';
export { QueryObserverResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
export { MutationKey } from './_tsup-dts-rollup.cjs';
export { MutationStatus } from './_tsup-dts-rollup.cjs';
export { MutationScope } from './_tsup-dts-rollup.cjs';
export { MutationMeta } from './_tsup-dts-rollup.cjs';
export { MutationFunctionContext } from './_tsup-dts-rollup.cjs';
export { MutationFunction } from './_tsup-dts-rollup.cjs';
export { MutationOptions } from './_tsup-dts-rollup.cjs';
export { MutationObserverOptions } from './_tsup-dts-rollup.cjs';
export { MutateOptions } from './_tsup-dts-rollup.cjs';
export { MutateFunction } from './_tsup-dts-rollup.cjs';
export { MutationObserverBaseResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverIdleResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverLoadingResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverErrorResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverSuccessResult } from './_tsup-dts-rollup.cjs';
export { MutationObserverResult } from './_tsup-dts-rollup.cjs';
export { CancelOptions } from './_tsup-dts-rollup.cjs';
export { SetDataOptions } from './_tsup-dts-rollup.cjs';
export { NotifyEventType } from './_tsup-dts-rollup.cjs';
export { NotifyEvent } from './_tsup-dts-rollup.cjs';

200
node_modules/@tanstack/solid-query/build/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,200 @@
export { DefinedUseBaseQueryResult } from './_tsup-dts-rollup.js';
export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.js';
export { DefinedUseQueryResult } from './_tsup-dts-rollup.js';
export { SolidInfiniteQueryOptions } from './_tsup-dts-rollup.js';
export { SolidMutationOptions } from './_tsup-dts-rollup.js';
export { SolidQueryOptions } from './_tsup-dts-rollup.js';
export { UseBaseMutationResult } from './_tsup-dts-rollup.js';
export { UseBaseQueryOptions } from './_tsup-dts-rollup.js';
export { UseBaseQueryResult } from './_tsup-dts-rollup.js';
export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
export { UseInfiniteQueryResult } from './_tsup-dts-rollup.js';
export { UseMutateAsyncFunction } from './_tsup-dts-rollup.js';
export { UseMutateFunction } from './_tsup-dts-rollup.js';
export { UseMutationOptions } from './_tsup-dts-rollup.js';
export { UseMutationResult } from './_tsup-dts-rollup.js';
export { UseQueryOptions } from './_tsup-dts-rollup.js';
export { UseQueryResult } from './_tsup-dts-rollup.js';
export { CreateBaseQueryOptions } from './_tsup-dts-rollup.js';
export { CreateBaseQueryResult } from './_tsup-dts-rollup.js';
export { CreateInfiniteQueryOptions } from './_tsup-dts-rollup.js';
export { CreateInfiniteQueryResult } from './_tsup-dts-rollup.js';
export { CreateMutateAsyncFunction } from './_tsup-dts-rollup.js';
export { CreateMutateFunction } from './_tsup-dts-rollup.js';
export { CreateMutationOptions } from './_tsup-dts-rollup.js';
export { CreateMutationResult } from './_tsup-dts-rollup.js';
export { CreateBaseMutationResult } from './_tsup-dts-rollup.js';
export { CreateQueryOptions } from './_tsup-dts-rollup.js';
export { CreateQueryResult } from './_tsup-dts-rollup.js';
export { DefinedCreateBaseQueryResult } from './_tsup-dts-rollup.js';
export { DefinedCreateInfiniteQueryResult } from './_tsup-dts-rollup.js';
export { DefinedCreateQueryResult } from './_tsup-dts-rollup.js';
export { QueryClient_alias_1 as QueryClient } from './_tsup-dts-rollup.js';
export { QueryObserverOptions_alias_1 as QueryObserverOptions } from './_tsup-dts-rollup.js';
export { DefaultOptions_alias_1 as DefaultOptions } from './_tsup-dts-rollup.js';
export { QueryClientConfig_alias_1 as QueryClientConfig } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverOptions_alias_1 as InfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
export { useQuery } from './_tsup-dts-rollup.js';
export { createQuery } from './_tsup-dts-rollup.js';
export { queryOptions } from './_tsup-dts-rollup.js';
export { DefinedInitialDataOptions } from './_tsup-dts-rollup.js';
export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.js';
export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.js';
export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.js';
export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.js';
export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.js';
export { useIsFetching } from './_tsup-dts-rollup.js';
export { createIsFetching } from './_tsup-dts-rollup.js';
export { useInfiniteQuery } from './_tsup-dts-rollup.js';
export { createInfiniteQuery } from './_tsup-dts-rollup.js';
export { infiniteQueryOptions } from './_tsup-dts-rollup.js';
export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
export { useMutation } from './_tsup-dts-rollup.js';
export { mutationOptions } from './_tsup-dts-rollup.js';
export { createMutation } from './_tsup-dts-rollup.js';
export { useIsMutating } from './_tsup-dts-rollup.js';
export { createIsMutating } from './_tsup-dts-rollup.js';
export { useMutationState } from './_tsup-dts-rollup.js';
export { createMutationState } from './_tsup-dts-rollup.js';
export { useQueries } from './_tsup-dts-rollup.js';
export { createQueries } from './_tsup-dts-rollup.js';
export { useIsRestoring } from './_tsup-dts-rollup.js';
export { IsRestoringProvider } from './_tsup-dts-rollup.js';
export { focusManager } from './_tsup-dts-rollup.js';
export { environmentManager } from './_tsup-dts-rollup.js';
export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.js';
export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.js';
export { dehydrate } from './_tsup-dts-rollup.js';
export { hydrate } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserver } from './_tsup-dts-rollup.js';
export { MutationCache } from './_tsup-dts-rollup.js';
export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.js';
export { MutationObserver } from './_tsup-dts-rollup.js';
export { defaultScheduler } from './_tsup-dts-rollup.js';
export { notifyManager } from './_tsup-dts-rollup.js';
export { onlineManager } from './_tsup-dts-rollup.js';
export { QueriesObserver } from './_tsup-dts-rollup.js';
export { QueryCache } from './_tsup-dts-rollup.js';
export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.js';
export { QueryObserver } from './_tsup-dts-rollup.js';
export { CancelledError } from './_tsup-dts-rollup.js';
export { isCancelledError } from './_tsup-dts-rollup.js';
export { timeoutManager } from './_tsup-dts-rollup.js';
export { ManagedTimerId } from './_tsup-dts-rollup.js';
export { TimeoutCallback } from './_tsup-dts-rollup.js';
export { TimeoutProvider } from './_tsup-dts-rollup.js';
export { hashKey } from './_tsup-dts-rollup.js';
export { isServer } from './_tsup-dts-rollup.js';
export { keepPreviousData } from './_tsup-dts-rollup.js';
export { matchMutation } from './_tsup-dts-rollup.js';
export { matchQuery } from './_tsup-dts-rollup.js';
export { noop } from './_tsup-dts-rollup.js';
export { partialMatchKey } from './_tsup-dts-rollup.js';
export { replaceEqualDeep } from './_tsup-dts-rollup.js';
export { shouldThrowError } from './_tsup-dts-rollup.js';
export { skipToken } from './_tsup-dts-rollup.js';
export { MutationFilters } from './_tsup-dts-rollup.js';
export { QueryFilters } from './_tsup-dts-rollup.js';
export { SkipToken } from './_tsup-dts-rollup.js';
export { Updater } from './_tsup-dts-rollup.js';
export { experimental_streamedQuery } from './_tsup-dts-rollup.js';
export { DehydratedState } from './_tsup-dts-rollup.js';
export { DehydrateOptions } from './_tsup-dts-rollup.js';
export { HydrateOptions } from './_tsup-dts-rollup.js';
export { Mutation } from './_tsup-dts-rollup.js';
export { MutationState } from './_tsup-dts-rollup.js';
export { QueriesObserverOptions } from './_tsup-dts-rollup.js';
export { Query } from './_tsup-dts-rollup.js';
export { QueryState } from './_tsup-dts-rollup.js';
export { NonUndefinedGuard } from './_tsup-dts-rollup.js';
export { DistributiveOmit } from './_tsup-dts-rollup.js';
export { OmitKeyof } from './_tsup-dts-rollup.js';
export { Override } from './_tsup-dts-rollup.js';
export { NoInfer } from './_tsup-dts-rollup.js';
export { Register } from './_tsup-dts-rollup.js';
export { DefaultError } from './_tsup-dts-rollup.js';
export { QueryKey } from './_tsup-dts-rollup.js';
export { dataTagSymbol } from './_tsup-dts-rollup.js';
export { dataTagErrorSymbol } from './_tsup-dts-rollup.js';
export { unsetMarker } from './_tsup-dts-rollup.js';
export { UnsetMarker } from './_tsup-dts-rollup.js';
export { AnyDataTag } from './_tsup-dts-rollup.js';
export { DataTag } from './_tsup-dts-rollup.js';
export { InferDataFromTag } from './_tsup-dts-rollup.js';
export { InferErrorFromTag } from './_tsup-dts-rollup.js';
export { QueryFunction } from './_tsup-dts-rollup.js';
export { StaleTime } from './_tsup-dts-rollup.js';
export { StaleTimeFunction } from './_tsup-dts-rollup.js';
export { QueryBooleanOption } from './_tsup-dts-rollup.js';
export { QueryPersister } from './_tsup-dts-rollup.js';
export { QueryFunctionContext } from './_tsup-dts-rollup.js';
export { InitialDataFunction } from './_tsup-dts-rollup.js';
export { PlaceholderDataFunction } from './_tsup-dts-rollup.js';
export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.js';
export { QueryKeyHashFunction } from './_tsup-dts-rollup.js';
export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.js';
export { GetNextPageParamFunction } from './_tsup-dts-rollup.js';
export { InfiniteData } from './_tsup-dts-rollup.js';
export { QueryMeta } from './_tsup-dts-rollup.js';
export { NetworkMode } from './_tsup-dts-rollup.js';
export { NotifyOnChangeProps } from './_tsup-dts-rollup.js';
export { QueryOptions } from './_tsup-dts-rollup.js';
export { InitialPageParam } from './_tsup-dts-rollup.js';
export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.js';
export { ThrowOnError } from './_tsup-dts-rollup.js';
export { WithRequired } from './_tsup-dts-rollup.js';
export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.js';
export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
export { FetchQueryOptions } from './_tsup-dts-rollup.js';
export { EnsureQueryDataOptions } from './_tsup-dts-rollup.js';
export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.js';
export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.js';
export { ResultOptions } from './_tsup-dts-rollup.js';
export { RefetchOptions } from './_tsup-dts-rollup.js';
export { InvalidateQueryFilters } from './_tsup-dts-rollup.js';
export { RefetchQueryFilters } from './_tsup-dts-rollup.js';
export { InvalidateOptions } from './_tsup-dts-rollup.js';
export { ResetOptions } from './_tsup-dts-rollup.js';
export { FetchNextPageOptions } from './_tsup-dts-rollup.js';
export { FetchPreviousPageOptions } from './_tsup-dts-rollup.js';
export { QueryStatus } from './_tsup-dts-rollup.js';
export { FetchStatus } from './_tsup-dts-rollup.js';
export { QueryObserverBaseResult } from './_tsup-dts-rollup.js';
export { QueryObserverPendingResult } from './_tsup-dts-rollup.js';
export { QueryObserverLoadingResult } from './_tsup-dts-rollup.js';
export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
export { QueryObserverSuccessResult } from './_tsup-dts-rollup.js';
export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
export { DefinedQueryObserverResult } from './_tsup-dts-rollup.js';
export { QueryObserverResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
export { MutationKey } from './_tsup-dts-rollup.js';
export { MutationStatus } from './_tsup-dts-rollup.js';
export { MutationScope } from './_tsup-dts-rollup.js';
export { MutationMeta } from './_tsup-dts-rollup.js';
export { MutationFunctionContext } from './_tsup-dts-rollup.js';
export { MutationFunction } from './_tsup-dts-rollup.js';
export { MutationOptions } from './_tsup-dts-rollup.js';
export { MutationObserverOptions } from './_tsup-dts-rollup.js';
export { MutateOptions } from './_tsup-dts-rollup.js';
export { MutateFunction } from './_tsup-dts-rollup.js';
export { MutationObserverBaseResult } from './_tsup-dts-rollup.js';
export { MutationObserverIdleResult } from './_tsup-dts-rollup.js';
export { MutationObserverLoadingResult } from './_tsup-dts-rollup.js';
export { MutationObserverErrorResult } from './_tsup-dts-rollup.js';
export { MutationObserverSuccessResult } from './_tsup-dts-rollup.js';
export { MutationObserverResult } from './_tsup-dts-rollup.js';
export { CancelOptions } from './_tsup-dts-rollup.js';
export { SetDataOptions } from './_tsup-dts-rollup.js';
export { NotifyEventType } from './_tsup-dts-rollup.js';
export { NotifyEvent } from './_tsup-dts-rollup.js';

521
node_modules/@tanstack/solid-query/build/index.js generated vendored Normal file
View File

@@ -0,0 +1,521 @@
import { MutationObserver, shouldThrowError, QueriesObserver, noop, QueryClient as QueryClient$1, replaceEqualDeep, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
export * from '@tanstack/query-core';
import { createContext, useContext, createRenderEffect, onCleanup, createMemo, createComputed, on, mergeProps, createResource, batch, onMount, createSignal, createEffect } from 'solid-js';
import { createComponent, isServer } from 'solid-js/web';
import { createStore, unwrap, reconcile } from 'solid-js/store';
// src/useQuery.ts
var QueryClientContext = createContext(void 0);
var useQueryClient = (queryClient) => {
if (queryClient) {
return queryClient;
}
const client = useContext(QueryClientContext);
if (!client) {
throw new Error("No QueryClient set, use QueryClientProvider to set one");
}
return client();
};
var QueryClientProvider = (props) => {
createRenderEffect((unmount) => {
unmount?.();
props.client.mount();
return props.client.unmount.bind(props.client);
});
onCleanup(() => props.client.unmount());
return createComponent(QueryClientContext.Provider, {
value: () => props.client,
get children() {
return props.children;
}
});
};
var IsRestoringContext = createContext(() => false);
var useIsRestoring = () => useContext(IsRestoringContext);
var IsRestoringProvider = IsRestoringContext.Provider;
// src/useBaseQuery.ts
function reconcileFn(store, result, reconcileOption, queryHash) {
if (reconcileOption === false) return result;
if (typeof reconcileOption === "function") {
const newData2 = reconcileOption(store.data, result.data);
return { ...result, data: newData2 };
}
let data = result.data;
if (store.data === void 0) {
try {
data = structuredClone(data);
} catch (error) {
}
}
const newData = reconcile(data, { key: reconcileOption })(store.data);
return { ...result, data: newData };
}
var hydratableObserverResult = (query, result) => {
if (!isServer) return result;
const obj = {
...unwrap(result),
// During SSR, functions cannot be serialized, so we need to remove them
// This is safe because we will add these functions back when the query is hydrated
refetch: void 0
};
if ("fetchNextPage" in result) {
obj.fetchNextPage = void 0;
obj.fetchPreviousPage = void 0;
}
obj.hydrationData = {
state: query.state,
queryKey: query.queryKey,
queryHash: query.queryHash,
...query.meta && { meta: query.meta }
};
return obj;
};
function useBaseQuery(options, Observer, queryClient) {
const client = createMemo(() => useQueryClient(queryClient?.()));
const isRestoring = useIsRestoring();
let unsubscribeQueued = false;
const defaultedOptions = createMemo(() => {
const defaultOptions = client().defaultQueryOptions(options());
defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
defaultOptions.structuralSharing = false;
if (isServer) {
defaultOptions.retry = false;
defaultOptions.throwOnError = true;
defaultOptions.experimental_prefetchInRender = true;
}
return defaultOptions;
});
const initialOptions = defaultedOptions();
const [observer, setObserver] = createSignal(
new Observer(client(), defaultedOptions())
);
let observerResult = observer().getOptimisticResult(defaultedOptions());
const [state, setState] = createStore(observerResult);
const createServerSubscriber = (resolve, reject) => {
return observer().subscribe((result) => {
notifyManager.batchCalls(() => {
const query = observer().getCurrentQuery();
const unwrappedResult = hydratableObserverResult(query, result);
if (result.data !== void 0 && unwrappedResult.isError) {
reject(unwrappedResult.error);
unsubscribeIfQueued();
} else {
resolve(unwrappedResult);
unsubscribeIfQueued();
}
})();
});
};
const unsubscribeIfQueued = () => {
if (unsubscribeQueued) {
unsubscribe?.();
unsubscribeQueued = false;
}
};
const createClientSubscriber = () => {
const obs = observer();
return obs.subscribe((result) => {
observerResult = result;
queueMicrotask(() => {
if (unsubscribe) {
refetch();
}
});
});
};
function setStateWithReconciliation(res) {
const opts = observer().options;
const reconcileOptions = opts.reconcile;
setState((store) => {
return reconcileFn(
store,
res,
reconcileOptions === void 0 ? false : reconcileOptions,
opts.queryHash
);
});
}
function createDeepSignal() {
return [
() => state,
(v) => {
const unwrapped = unwrap(state);
if (typeof v === "function") {
v = v(unwrapped);
}
if (v?.hydrationData) {
const { hydrationData, ...rest } = v;
v = rest;
}
setStateWithReconciliation(v);
}
];
}
let unsubscribe = null;
let resolver = null;
const [queryResource, { refetch }] = createResource(
() => {
const obs = observer();
return new Promise((resolve, reject) => {
resolver = resolve;
if (isServer) {
unsubscribe = createServerSubscriber(resolve, reject);
} else if (!unsubscribe && !isRestoring()) {
unsubscribe = createClientSubscriber();
}
obs.updateResult();
if (observerResult.isError && !observerResult.isFetching && !isRestoring() && shouldThrowError(obs.options.throwOnError, [
observerResult.error,
obs.getCurrentQuery()
])) {
setStateWithReconciliation(observerResult);
return reject(observerResult.error);
}
if (!observerResult.isLoading) {
resolver = null;
return resolve(
hydratableObserverResult(obs.getCurrentQuery(), observerResult)
);
}
setStateWithReconciliation(observerResult);
});
},
{
storage: createDeepSignal,
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 && "hydrationData" in info.value) {
hydrate(client(), {
// @ts-expect-error - hydrationData is not correctly typed internally
queries: [{ ...info.value.hydrationData }]
});
}
if (unsubscribe) return;
const newOptions = { ...initialOptions };
if ((initialOptions.staleTime || !initialOptions.initialData) && info.value) {
newOptions.refetchOnMount = false;
}
observer().setOptions(newOptions);
setStateWithReconciliation(observer().getOptimisticResult(newOptions));
unsubscribe = createClientSubscriber();
}
}
);
createComputed(
on(
client,
(c) => {
if (unsubscribe) {
unsubscribe();
}
const newObserver = new Observer(c, defaultedOptions());
unsubscribe = createClientSubscriber();
setObserver(newObserver);
},
{
defer: true
}
)
);
createComputed(
on(
isRestoring,
(restoring) => {
if (!restoring && !isServer) {
refetch();
}
},
{ defer: true }
)
);
onCleanup(() => {
if (isServer && queryResource.loading) {
unsubscribeQueued = true;
return;
}
if (unsubscribe) {
unsubscribe();
unsubscribe = null;
}
if (resolver && !isServer) {
resolver(observerResult);
resolver = null;
}
});
createComputed(
on(
[observer, defaultedOptions],
([obs, opts]) => {
obs.setOptions(opts);
setStateWithReconciliation(obs.getOptimisticResult(opts));
refetch();
},
{ defer: true }
)
);
const handler = {
get(target, prop) {
if (prop === "data") {
if (state.data !== void 0) {
return queryResource.latest?.data;
}
return queryResource()?.data;
}
return Reflect.get(target, prop);
}
};
return new Proxy(state, handler);
}
// src/useQuery.ts
function useQuery(options, queryClient) {
return useBaseQuery(
createMemo(() => options()),
QueryObserver,
queryClient
);
}
function useInfiniteQuery(options, queryClient) {
return useBaseQuery(
createMemo(() => options()),
InfiniteQueryObserver,
queryClient
);
}
function useMutation(options, queryClient) {
const client = createMemo(() => 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;
}
function useQueries(queriesOptions, queryClient) {
const client = createMemo(() => useQueryClient(queryClient?.()));
const isRestoring = useIsRestoring();
const defaultedQueries = createMemo(
() => queriesOptions().queries.map(
(options) => mergeProps(
client().defaultQueryOptions(options),
{
get _optimisticResults() {
return isRestoring() ? "isRestoring" : "optimistic";
}
}
)
)
);
const observer = new QueriesObserver(
client(),
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
const [state, setState] = createStore(
observer.getOptimisticResult(
defaultedQueries(),
queriesOptions().combine
)[1]()
);
createRenderEffect(
on(
() => queriesOptions().queries.length,
() => setState(
observer.getOptimisticResult(
defaultedQueries(),
queriesOptions().combine
)[1]()
)
)
);
const dataResources = createMemo(
on(
() => state.length,
() => state.map((queryRes) => {
const dataPromise = () => new Promise((resolve) => {
if (queryRes.isFetching && queryRes.isLoading) return;
resolve(unwrap(queryRes.data));
});
return createResource(dataPromise);
})
)
);
batch(() => {
const dataResources_ = dataResources();
for (let index = 0; index < dataResources_.length; index++) {
const dataResource = dataResources_[index];
dataResource[1].mutate(() => unwrap(state[index].data));
dataResource[1].refetch();
}
});
let taskQueue = [];
const subscribeToObserver = () => observer.subscribe((result) => {
taskQueue.push(() => {
batch(() => {
const dataResources_ = dataResources();
for (let index = 0; index < dataResources_.length; index++) {
const dataResource = dataResources_[index];
const unwrappedResult = { ...unwrap(result[index]) };
setState(index, unwrap(unwrappedResult));
dataResource[1].mutate(() => unwrap(state[index].data));
dataResource[1].refetch();
}
});
});
queueMicrotask(() => {
const taskToRun = taskQueue.pop();
if (taskToRun) taskToRun();
taskQueue = [];
});
});
let unsubscribe = noop;
createComputed((cleanup) => {
cleanup?.();
unsubscribe = isRestoring() ? noop : subscribeToObserver();
return () => queueMicrotask(unsubscribe);
});
onCleanup(unsubscribe);
onMount(() => {
observer.setQueries(
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
});
createComputed(() => {
observer.setQueries(
defaultedQueries(),
queriesOptions().combine ? {
combine: queriesOptions().combine
} : void 0
);
});
const handler = (index) => ({
get(target, prop) {
if (prop === "data") {
return dataResources()[index][0]();
}
return Reflect.get(target, prop);
}
});
const getProxies = () => state.map((s, index) => {
return new Proxy(s, handler(index));
});
const [proxyState, setProxyState] = createStore(getProxies());
createRenderEffect(() => setProxyState(getProxies()));
return proxyState;
}
var QueryClient = class extends QueryClient$1 {
constructor(config = {}) {
super(config);
}
};
// src/queryOptions.ts
function queryOptions(options) {
return options;
}
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;
}
// src/infiniteQueryOptions.ts
function infiniteQueryOptions(options) {
return options;
}
// src/mutationOptions.ts
function mutationOptions(options) {
return options;
}
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;
}
function getResult(mutationCache, options) {
return mutationCache.findAll(options.filters).map(
(mutation) => options.select ? options.select(mutation) : mutation.state
);
}
function useMutationState(options = () => ({}), queryClient) {
const client = createMemo(() => useQueryClient(queryClient?.()));
const mutationCache = createMemo(() => client().getMutationCache());
const [result, setResult] = createSignal(
getResult(mutationCache(), options())
);
createEffect(() => {
const unsubscribe = mutationCache().subscribe(() => {
const nextResult = replaceEqualDeep(
result(),
getResult(mutationCache(), options())
);
if (result() !== nextResult) {
setResult(nextResult);
}
});
onCleanup(unsubscribe);
});
return result;
}
// src/index.ts
var createQuery = useQuery;
var createInfiniteQuery = useInfiniteQuery;
var createMutation = useMutation;
var createQueries = useQueries;
export { IsRestoringProvider, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, useIsFetching as createIsFetching, useIsMutating as createIsMutating, createMutation, useMutationState as createMutationState, createQueries, createQuery, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };