reactjrx 1.67.4 → 1.69.0

package/dist/lib/queries/client/queries/observer/types.d.ts

@@ -0,0 +1,241 @@
+import { type NonFunctionGuard, type WithRequired } from "../../../../utils/types";
+import { type QueryKey } from "../../keys/types";
+import { type DefaultError } from "../../types";
+import { type Query } from "../query/Query";
+import { type ThrowOnError, type QueryOptions, type PlaceholderDataFunction, type NotifyOnChangeProps, type RefetchOptions, type QueryStatus, type FetchStatus, type FetchNextPageOptions, type FetchPreviousPageOptions } from "../types";
+export interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam> {
+    /**
+     * Set this to `false` to disable automatic refetching when the query mounts or changes query keys.
+     * To refetch the query, use the `refetch` method returned from the `useQuery` instance.
+     * Defaults to `true`.
+     */
+    enabled?: boolean;
+    /**
+     * The time in milliseconds after data is considered stale.
+     * If set to `Infinity`, the data will never be considered stale.
+     */
+    staleTime?: number;
+    /**
+     * If set to a number, the query will continuously refetch at this frequency in milliseconds.
+     * If set to a function, the function will be executed with the latest data and query to compute a frequency
+     * Defaults to `false`.
+     */
+    refetchInterval?: number | false | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => number | false | undefined);
+    /**
+     * If set to `true`, the query will continue to refetch while their tab/window is in the background.
+     * Defaults to `false`.
+     */
+    refetchIntervalInBackground?: boolean;
+    /**
+     * If set to `true`, the query will refetch on window focus if the data is stale.
+     * If set to `false`, the query will not refetch on window focus.
+     * If set to `'always'`, the query will always refetch on window focus.
+     * If set to a function, the function will be executed with the latest data and query to compute the value.
+     * Defaults to `true`.
+     */
+    refetchOnWindowFocus?: boolean | "always" | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | "always");
+    /**
+     * If set to `true`, the query will refetch on reconnect if the data is stale.
+     * If set to `false`, the query will not refetch on reconnect.
+     * If set to `'always'`, the query will always refetch on reconnect.
+     * If set to a function, the function will be executed with the latest data and query to compute the value.
+     * Defaults to the value of `networkOnline` (`true`)
+     */
+    refetchOnReconnect?: boolean | "always" | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | "always");
+    /**
+     * If set to `true`, the query will refetch on mount if the data is stale.
+     * If set to `false`, will disable additional instances of a query to trigger background refetches.
+     * If set to `'always'`, the query will always refetch on mount.
+     * If set to a function, the function will be executed with the latest data and query to compute the value
+     * Defaults to `true`.
+     */
+    refetchOnMount?: boolean | "always" | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | "always");
+    /**
+     * If set to `false`, the query will not be retried on mount if it contains an error.
+     * Defaults to `true`.
+     */
+    retryOnMount?: boolean;
+    /**
+     * If set, the component will only re-render if any of the listed properties change.
+     * When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.
+     * When set to `'all'`, the component will re-render whenever a query is updated.
+     * When set to a function, the function will be executed to compute the list of properties.
+     * By default, access to properties will be tracked, and the component will only re-render when one of the tracked properties change.
+     */
+    notifyOnChangeProps?: NotifyOnChangeProps;
+    /**
+     * Whether errors should be thrown instead of setting the `error` property.
+     * If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.
+     * If set to `false` and `suspense` is `false`, errors are returned as state.
+     * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).
+     * Defaults to `false`.
+     */
+    throwOnError?: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>;
+    /**
+     * This option can be used to transform or select a part of the data returned by the query function.
+     */
+    select?: (data: TQueryData) => TData;
+    /**
+     * If set to `true`, the query will suspend when `status === 'pending'`
+     * and throw errors when `status === 'error'`.
+     * Defaults to `false`.
+     */
+    suspense?: boolean;
+    /**
+     * If set, this value will be used as the placeholder data for this particular query observer while the query is still in the `loading` data and no initialData has been provided.
+     */
+    placeholderData?: NonFunctionGuard<TQueryData> | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>;
+    _optimisticResults?: "optimistic" | "isRestoring";
+}
+export type DefaultedQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, "throwOnError" | "refetchOnReconnect" | "queryHash">;
+export interface QueryObserverBaseResult<TData = unknown, TError = DefaultError> {
+    data: TData | undefined;
+    dataUpdatedAt: number;
+    error: TError | null;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: TError | null;
+    errorUpdateCount: number;
+    isError: boolean;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isPending: boolean;
+    isLoadingError: boolean;
+    /**
+     * @deprecated isInitialLoading is being deprecated in favor of isLoading
+     * and will be removed in the next major version.
+     */
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetchError: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isSuccess: boolean;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<TData, TError>>;
+    status: QueryStatus;
+    fetchStatus: FetchStatus;
+}
+export interface QueryObserverPendingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+}
+export interface QueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: TError;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+}
+export interface QueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    data: TData;
+    error: TError;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+}
+export interface InfiniteQueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: TData;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+}
+export interface InfiniteQueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: TData;
+    error: TError;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+}
+export type DefinedInfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverRefetchErrorResult<TData, TError> | InfiniteQueryObserverSuccessResult<TData, TError>;
+export interface InfiniteQueryObserverBaseResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+    fetchPreviousPage: (options?: FetchPreviousPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+}
+export interface QueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    data: TData;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+}
+export interface QueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+}
+export type DefinedQueryObserverResult<TData = unknown, TError = DefaultError> = QueryObserverRefetchErrorResult<TData, TError> | QueryObserverSuccessResult<TData, TError>;
+export interface InfiniteQueryObserverPendingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+}
+export interface InfiniteQueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+}
+export interface InfiniteQueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: TError;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+}
+export type QueryObserverResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError> | QueryObserverLoadingErrorResult<TData, TError> | QueryObserverLoadingResult<TData, TError> | QueryObserverPendingResult<TData, TError>;
+export type InfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError> | InfiniteQueryObserverLoadingErrorResult<TData, TError> | InfiniteQueryObserverLoadingResult<TData, TError> | InfiniteQueryObserverPendingResult<TData, TError>;
+export type QueryObserverListener<TData, TError> = (result: QueryObserverResult<TData, TError>) => void;

package/dist/lib/queries/client/queries/query/Query.d.ts

@@ -0,0 +1,71 @@
+import { type Observable, Subject, BehaviorSubject } from "rxjs";
+import { type QueryKey } from "../../keys/types";
+import { type DefaultError } from "../../types";
+import { type QueryCache } from "../cache/QueryCache";
+import { type SetDataOptions, type QueryOptions } from "../types";
+import { type QueryMeta, type FetchOptions, type QueryState } from "./types";
+import { type CancelOptions } from "../retryer/types";
+import { type QueryObserver } from "../observer/QueryObserver";
+interface QueryConfig<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+    cache: QueryCache;
+    queryKey: TQueryKey;
+    queryHash: string;
+    options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    defaultOptions?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    state?: QueryState<TData, TError>;
+}
+export declare class Query<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+    #private;
+    queryKey: TQueryKey;
+    queryHash: string;
+    gcTime: number;
+    options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    state: QueryState<TData, TError>;
+    protected executeSubject: Subject<FetchOptions | undefined>;
+    protected cancelSubject: Subject<CancelOptions | undefined>;
+    protected setDataSubject: Subject<{
+        data: TData;
+        options?: (SetDataOptions & {
+            manual: boolean;
+        }) | undefined;
+    }>;
+    protected invalidatedSubject: Subject<void>;
+    protected resetSubject: Subject<void>;
+    protected destroySubject: Subject<void>;
+    protected observersSubject: BehaviorSubject<QueryObserver<unknown, Error, unknown, unknown, QueryKey>[]>;
+    protected abortSignalConsumed: boolean;
+    observerCount$: Observable<number>;
+    observers$: Observable<QueryObserver<unknown, Error, unknown, unknown, QueryKey>[]>;
+    state$: Observable<typeof this.state>;
+    constructor(config: QueryConfig<TQueryFnData, TError, TData, TQueryKey>);
+    setOptions(options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>): QueryOptions<TQueryFnData, TError, TData, TQueryKey, never>;
+    get meta(): QueryMeta | undefined;
+    get success$(): Observable<{
+        data: TData | undefined;
+        status: import("../types").QueryStatus;
+    }>;
+    get error$(): Observable<{
+        error: TError | null;
+        status: import("../types").QueryStatus;
+    }>;
+    get settled$(): Observable<{
+        status: import("../types").QueryStatus;
+    }>;
+    observe(observer: QueryObserver<any, any, any, any, any>): Observable<QueryState<TData, TError>>;
+    getObserversCount(): number;
+    protected updateGcTime(newGcTime: number | undefined): number;
+    isActive(): boolean;
+    isDisabled(): boolean;
+    isStale(): boolean;
+    isStaleByTime(staleTime?: number): boolean;
+    getFetchResultAsPromise(): Promise<TData>;
+    fetch(options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>, fetchOptions?: FetchOptions): Promise<TData>;
+    setData(newData: TData, options?: SetDataOptions & {
+        manual: boolean;
+    }): TData;
+    invalidate(): void;
+    cancel(options?: CancelOptions): Promise<void>;
+    destroy(): void;
+    reset(): void;
+}
+export {};

package/dist/lib/queries/client/queries/query/delayOnNetworkMode.d.ts

@@ -0,0 +1,6 @@
+import { type Observable } from "rxjs";
+import { type QueryOptions } from "../types";
+import { type QueryState } from "./types";
+type Result<TData, TError> = Partial<QueryState<TData, TError>>;
+export declare const delayOnNetworkMode: <TData, TError>(options: Pick<QueryOptions, "networkMode">) => (source: Observable<Partial<QueryState<TData, TError>>>) => Observable<Partial<QueryState<TData, TError>>>;
+export {};

package/dist/lib/queries/client/queries/query/delayUntilFocus.d.ts

@@ -0,0 +1,2 @@
+import { type Observable } from "rxjs";
+export declare const delayUntilFocus: <T>(source: Observable<T>) => Observable<T>;

package/dist/lib/queries/client/queries/query/executeQuery.d.ts

@@ -0,0 +1,17 @@
+import { type QueryKey } from "../../keys/types";
+import { type QueryState } from "./types";
+import { type QueryOptions } from "../types";
+export declare const executeQuery: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: QueryOptions<TQueryFnData, TError, TData, TQueryKey, never> & {
+    queryKey: TQueryKey;
+    onSignalConsumed: () => void;
+    retry: (attempt: number, error: TError) => boolean;
+    retryAfterDelay: (attempt: number, error: TError) => boolean;
+}) => {
+    state$: import("rxjs").Observable<Partial<QueryState<TData, TError>> | {
+        status: "pending";
+        fetchStatus: "fetching" | "paused";
+    } | {
+        fetchStatus: "idle";
+    }>;
+    abortController: AbortController;
+};

package/dist/lib/queries/client/queries/query/getDefaultState.d.ts

@@ -0,0 +1,4 @@
+import { type QueryKey } from "../../keys/types";
+import { type QueryOptions } from "../types";
+import { type QueryState } from "./types";
+export declare function getDefaultState<TQueryFnData, TError, TData, TQueryKey extends QueryKey>(options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>): QueryState<TData, TError>;

package/dist/lib/queries/client/queries/query/operators.d.ts

@@ -0,0 +1,13 @@
+import { type Observable } from "rxjs";
+import { type QueryOptions } from "../types";
+import { type QueryState } from "./types";
+export declare const reduceState: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData>({ getOptions, getState, initialState }: {
+    initialState: QueryState<TData, TError>;
+    getState: () => QueryState<TData, TError>;
+    getOptions: () => QueryOptions<TQueryFnData, TError, TData, any, never>;
+}) => (source: Observable<{
+    command: "invalidate" | "cancel" | "reset" | "setData" | "execute";
+    state: Partial<QueryState<TData, TError>>;
+}>) => Observable<QueryState<TData, TError>>;
+export declare const isQueryFinished: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData>(source: Observable<Partial<QueryState<TData, TError>>>) => Observable<boolean>;
+export declare const takeUntilFinished: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData>(source: Observable<Partial<QueryState<TData, TError>>>) => Observable<Partial<QueryState<TData, TError>>>;

package/dist/lib/queries/client/queries/query/types.d.ts

@@ -0,0 +1,93 @@
+import { type Observable } from "rxjs";
+import { type QueryKey } from "../../keys/types";
+import { type DefaultError, type Register } from "../../types";
+import { type FetchStatus, type QueryStatus, type QueryOptions } from "../types";
+import { type Query } from "./Query";
+export interface SetStateOptions {
+    meta?: any;
+}
+export type FetchDirection = "forward" | "backward";
+export interface QueryState<TData = unknown, TError = DefaultError> {
+    data: TData | undefined;
+    dataUpdateCount: number;
+    dataUpdatedAt: number;
+    error: TError | null;
+    errorUpdateCount: number;
+    errorUpdatedAt: number;
+    fetchFailureCount: number;
+    fetchFailureReason: TError | null;
+    fetchMeta: FetchMeta | null;
+    isInvalidated: boolean;
+    status: QueryStatus;
+    fetchStatus: FetchStatus;
+}
+export type QueryMeta = Register extends {
+    queryMeta: infer TQueryMeta;
+} ? TQueryMeta extends Record<string, unknown> ? TQueryMeta : Record<string, unknown> : Record<string, unknown>;
+export type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? {
+    queryKey: TQueryKey;
+    signal: AbortSignal;
+    meta: QueryMeta | undefined;
+} : {
+    queryKey: TQueryKey;
+    signal: AbortSignal;
+    pageParam: TPageParam;
+    direction: FetchDirection;
+    meta: QueryMeta | undefined;
+};
+export type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = ((context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T> | Observable<T>) | Observable<T>;
+export interface FetchMeta {
+    fetchMore?: {
+        direction: FetchDirection;
+    };
+}
+export interface FetchOptions {
+    cancelRefetch?: boolean;
+    meta?: FetchMeta;
+}
+export interface FetchContext<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+    fetchFn: () => unknown | Promise<unknown>;
+    fetchOptions?: FetchOptions;
+    signal: AbortSignal;
+    options: QueryOptions<TQueryFnData, TError, TData, any>;
+    queryKey: TQueryKey;
+    state: QueryState<TData, TError>;
+}
+export interface QueryBehavior<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+    onFetch: (context: FetchContext<TQueryFnData, TError, TData, TQueryKey>, query: Query) => void;
+}
+interface FailedAction<TError> {
+    type: "failed";
+    failureCount: number;
+    error: TError;
+}
+interface FetchAction {
+    type: "fetch";
+    meta?: FetchMeta;
+}
+interface SuccessAction<TData> {
+    data: TData | undefined;
+    type: "success";
+    dataUpdatedAt?: number;
+    manual?: boolean;
+}
+interface ErrorAction<TError> {
+    type: "error";
+    error: TError;
+}
+interface InvalidateAction {
+    type: "invalidate";
+}
+interface PauseAction {
+    type: "pause";
+}
+interface ContinueAction {
+    type: "continue";
+}
+interface SetStateAction<TData, TError> {
+    type: "setState";
+    state: Partial<QueryState<TData, TError>>;
+    setStateOptions?: SetStateOptions;
+}
+export type Action<TData, TError> = ContinueAction | ErrorAction<TError> | FailedAction<TError> | FetchAction | InvalidateAction | PauseAction | SetStateAction<TData, TError> | SuccessAction<TData>;
+export {};

package/dist/lib/queries/client/queries/retryer/CancelledError.d.ts

@@ -0,0 +1,6 @@
+import { type CancelOptions } from "./types";
+export declare class CancelledError {
+    revert?: boolean;
+    silent?: boolean;
+    constructor(options?: CancelOptions);
+}

package/dist/lib/queries/client/queries/retryer/types.d.ts

@@ -0,0 +1,4 @@
+export interface CancelOptions {
+    revert?: boolean;
+    silent?: boolean;
+}

package/dist/lib/queries/client/queries/retryer/utils.d.ts

@@ -0,0 +1,2 @@
+import { CancelledError } from "./CancelledError";
+export declare function isCancelledError(value: any): value is CancelledError;

package/dist/lib/queries/client/queries/types.d.ts

@@ -0,0 +1,112 @@
+import { type NoInfer, type WithRequired } from "../../../utils/types";
+import { type QueryKey } from "../keys/types";
+import { type DefaultError } from "../types";
+import { type InfiniteQueryObserverResult } from "./observer/types";
+import { type Query } from "./query/Query";
+import { type QueryMeta, type QueryFunction, type QueryFunctionContext, type QueryBehavior } from "./query/types";
+export declare const dataTagSymbol: unique symbol;
+export type DataTag<Type, Value> = Type & {
+    [dataTagSymbol]: Value;
+};
+export type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput);
+export interface SetDataOptions {
+    updatedAt?: number;
+}
+export type QueryStatus = "pending" | "error" | "success";
+export type FetchStatus = "fetching" | "paused" | "idle";
+export type NetworkMode = "online" | "always" | "offlineFirst";
+export type QueryKeyHashFunction<TQueryKey extends QueryKey> = (queryKey: TQueryKey) => string;
+export type InitialDataFunction<T> = () => T | undefined;
+export interface ResultOptions {
+    throwOnError?: boolean;
+}
+export interface RefetchOptions extends ResultOptions {
+    cancelRefetch?: boolean;
+}
+export interface FetchNextPageOptions extends ResultOptions {
+    cancelRefetch?: boolean;
+}
+export interface FetchPreviousPageOptions extends ResultOptions {
+    cancelRefetch?: boolean;
+}
+export type NotifyOnChangeProps = Array<keyof InfiniteQueryObserverResult> | "all" | (() => Array<keyof InfiniteQueryObserverResult> | "all");
+export type ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey extends QueryKey> = boolean | ((error: TError, query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean);
+export type QueryPersister<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? (queryFn: QueryFunction<T, TQueryKey, never>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T> : (queryFn: QueryFunction<T, TQueryKey, TPageParam>, context: QueryFunctionContext<TQueryKey>, query: Query) => T | Promise<T>;
+export interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> {
+    /**
+     * If `false`, failed queries will not retry by default.
+     * If `true`, failed queries will retry infinitely., failureCount: num
+     * If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
+     * If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
+     */
+    retry?: boolean | number | ((failureCount: number, error: TError) => boolean);
+    retryDelay?: number | ((failureCount: number, error: TError) => number);
+    networkMode?: NetworkMode;
+    /**
+     * The time in milliseconds that unused/inactive cache data remains in memory.
+     * When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.
+     * When different garbage collection times are specified, the longest one will be used.
+     * Setting it to `Infinity` will disable garbage collection.
+     */
+    gcTime?: number;
+    queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
+    persister?: QueryPersister<NoInfer<TQueryFnData>, NoInfer<TQueryKey>, NoInfer<TPageParam>>;
+    queryHash?: string;
+    queryKey?: TQueryKey;
+    queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>;
+    initialData?: TData | InitialDataFunction<TData>;
+    initialDataUpdatedAt?: number | (() => number | undefined);
+    behavior?: QueryBehavior<TQueryFnData, TError, TData, TQueryKey>;
+    /**
+     * Set this to `false` to disable structural sharing 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 structural sharing logic.
+     * Defaults to `true`.
+     */
+    structuralSharing?: boolean | (<T>(oldData: T | undefined, newData: T) => T);
+    _defaulted?: boolean;
+    /**
+     * Additional payload to be stored on each query.
+     * Use this property to pass information that can be used in other places.
+     */
+    meta?: QueryMeta;
+    /**
+     * Maximum number of pages to store in the data of an infinite query.
+     */
+    maxPages?: number;
+}
+export type QueryTypeFilter = "all" | "active" | "inactive";
+export interface QueryFilters {
+    /**
+     * Filter to active queries, inactive queries or all queries
+     */
+    type?: QueryTypeFilter;
+    /**
+     * Match query key exactly
+     */
+    exact?: boolean;
+    /**
+     * Include queries matching this predicate function
+     */
+    predicate?: (query: Query) => boolean;
+    /**
+     * Include queries matching this query key
+     */
+    queryKey?: QueryKey;
+    /**
+     * Include or exclude stale queries
+     */
+    stale?: boolean;
+    /**
+     * Include queries matching their fetchStatus
+     */
+    fetchStatus?: FetchStatus;
+}
+export type PlaceholderDataFunction<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = (previousData: TQueryData | undefined, previousQuery: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => TQueryData | undefined;
+export interface FetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, "queryKey"> {
+    /**
+     * The time in milliseconds after data is considered stale.
+     * If the data is fresh it will be returned from the cache.
+     */
+    staleTime?: number;
+}
+export type QueriesPlaceholderDataFunction<TQueryData> = (previousData: undefined, previousQuery: undefined) => TQueryData | undefined;

package/dist/lib/queries/client/queries/utils.d.ts

@@ -0,0 +1,8 @@
+import { type QueryKey } from "../keys/types";
+import { type Query } from "./query/Query";
+import { type QueryOptions, type QueryFilters, type Updater } from "./types";
+export declare function hashQueryKeyByOptions<TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: QueryOptions<any, any, any, TQueryKey>): string;
+export declare function matchQuery(filters: QueryFilters, query: Query<any, any, any, any>): boolean;
+export declare function timeUntilStale(updatedAt: number, staleTime?: number): number;
+export declare function functionalUpdate<TInput, TOutput>(updater: Updater<TInput, TOutput>, input: TInput): TOutput;
+export declare function replaceData<TData, TOptions extends QueryOptions<any, any, any, any>>(prevData: TData | undefined, data: TData, options: TOptions): TData;

package/dist/lib/queries/client/store.d.ts

@@ -0,0 +1,25 @@
+import { BehaviorSubject, type Observable, Subject } from "rxjs";
+export declare class Store<Entity extends {
+    state$: Observable<any>;
+}> {
+    /**
+     * @important
+     * Query store. Could be turned into a map for more performance.
+     */
+    protected readonly entriesSubject: BehaviorSubject<Entity[]>;
+    protected readonly changeSubject: Subject<{
+        entity: Entity;
+    } & ({
+        type: "added";
+    } | {
+        type: "removed";
+    })>;
+    readonly entries$: Observable<Entity[]>;
+    readonly added$: Observable<Entity>;
+    readonly removed$: Observable<Entity>;
+    readonly stateChange$: Observable<Entity>;
+    getValues(): Entity[];
+    remove(entity: Entity): void;
+    add(entity: Entity): void;
+    find(predicate: (entity: Entity) => boolean): Entity | undefined;
+}

package/dist/lib/queries/client/tests/utils.d.ts

@@ -1,4 +1,10 @@
-import { type QueryClient } from "../createClient";
+import { type QueryClient } from "../QueryClient";
 import { type MutationOptions } from "../mutations/mutation/types";
+import { type SpyInstance } from "vitest";
 export declare function queryKey(): string[];
 export declare const executeMutation: <TVariables>(queryClient: QueryClient, options: MutationOptions<any, any, TVariables, any>, variables: TVariables) => Promise<import("../mutations/mutation/types").MutationState<any, any, TVariables, any>>;
+export declare function mockOnlineManagerIsOnline(value: boolean): {
+    mockReturnValue: (_: boolean) => void;
+    mockRestore: () => void;
+};
+export declare function mockVisibilityState(value: DocumentVisibilityState): SpyInstance<[], DocumentVisibilityState>;