reactjrx 1.68.0 → 1.69.0

package/dist/lib/binding/types.d.ts

@@ -0,0 +1,2 @@
+import { type Observable } from "rxjs";
+export type SubscribeSource<Data> = (() => Observable<Data>) | Promise<Data> | Observable<Data> | (() => Promise<Data>) | (() => Data) | Data;

package/dist/lib/binding/useObservableEvent.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+/**
+ * This creates an event handler and an observable that represents calls to that handler.
+ */
+export declare const useObserveCallback: <T = void>() => readonly [import("react").MutableRefObject<import("rxjs").Observable<T>>, (arg: T) => void];

package/dist/lib/binding/useObservableState.d.ts

@@ -0,0 +1,16 @@
+import { type Observable } from "rxjs";
+/**
+ * If you need to represent some piece of state as an observable and also want the ability to change
+ * this state during the lifetime of the component, useObservableState
+ * is for you. It acts like React.useState(), only that
+ * it returns an observable representing changes to the
+ * value instead of the value itself. The callback/setter
+ * returned acts like a the regular callback you
+ * would otherwise get from React.useState. This is useful when you want
+ * to compose the state change together with other observables.
+ *
+ * @important
+ * The last array value is the value itself in case
+ * you need a direct reference to the value
+ */
+export declare const useObservableState: <T>(defaultValue: T) => [Observable<T>, (value: T) => void, T];

package/dist/lib/binding/useSubscribe.d.ts

@@ -1,4 +1,3 @@
 import { type DependencyList } from "react";
-import { type Observable } from "rxjs";
-export declare function useSubscribe<T>(source: Observable<T>): void;
-export declare function useSubscribe<T>(source$: () => Observable<T>, deps: DependencyList): void;
+import { type SubscribeSource } from "./types";
+export declare function useSubscribe<T>(source: SubscribeSource<T>, deps?: DependencyList): void;

package/dist/lib/binding/useSubscribeEffect.d.ts

@@ -0,0 +1,11 @@
+import { type DependencyList } from "react";
+import { type SubscribeSource } from "./types";
+interface Option {
+    retry?: boolean;
+    onError?: (error: unknown) => void;
+}
+export declare function useSubscribeEffect<T>(source: SubscribeSource<T>): void;
+export declare function useSubscribeEffect<T>(source: SubscribeSource<T>, options: Option): void;
+export declare function useSubscribeEffect<T>(source: SubscribeSource<T>, deps: DependencyList): void;
+export declare function useSubscribeEffect<T>(source: SubscribeSource<T>, options: Option, deps: DependencyList): void;
+export {};

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

@@ -0,0 +1,48 @@
+import { type MutationKey } from "./mutations/types";
+import { MutationCache } from "./mutations/cache/MutationCache";
+import { type MutationObserverOptions } from "./mutations/observers/types";
+import { type MutationOptions } from "./mutations/mutation/types";
+import { QueryCache } from "./queries/cache/QueryCache";
+import { type DataTag, type Updater, type FetchQueryOptions, type QueryFilters, type SetDataOptions, type RefetchOptions } from "./queries/types";
+import { type RefetchQueryFilters, type DefaultError, type InvalidateOptions, type InvalidateQueryFilters, type ResetOptions } from "./types";
+import { type QueryKey } from "./keys/types";
+import { type DefaultedQueryObserverOptions, type QueryObserverOptions } from "./queries/observer/types";
+import { type NoInfer } from "../../utils/types";
+import { type QueryState } from "./queries/query/types";
+import { type CancelOptions } from "./queries/retryer/types";
+export interface DefaultOptions<TError = DefaultError> {
+    queries?: Omit<QueryObserverOptions<unknown, TError>, "suspense">;
+    mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
+}
+export interface QueryClientConfig {
+    queryCache?: QueryCache;
+    mutationCache?: MutationCache;
+    defaultOptions?: DefaultOptions;
+}
+export declare class QueryClient {
+    #private;
+    constructor({ mutationCache, queryCache, defaultOptions }?: QueryClientConfig);
+    mount(): void;
+    unmount(): void;
+    getMutationCache(): MutationCache;
+    getQueryCache(): QueryCache;
+    defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(options?: T): T;
+    defaultQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam> | DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<TData>;
+    prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    resetQueries(filters?: QueryFilters, options?: ResetOptions): Promise<void>;
+    refetchQueries(filters?: RefetchQueryFilters, options?: RefetchOptions): Promise<void>;
+    getQueryData<TQueryFnData = unknown, TTaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue> ? TaggedValue : TQueryFnData>(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined;
+    setQueryData<TQueryFnData = unknown, TaggedQueryKey extends QueryKey = QueryKey, TInferredQueryFnData = TaggedQueryKey extends DataTag<unknown, infer TaggedValue> ? TaggedValue : TQueryFnData>(queryKey: TaggedQueryKey, updater: Updater<NoInfer<TInferredQueryFnData> | undefined, NoInfer<TInferredQueryFnData> | undefined>, options?: SetDataOptions): TInferredQueryFnData | undefined;
+    getMutationDefaults(mutationKey: MutationKey): MutationObserverOptions<any, any, any, any>;
+    getQueryState<TQueryFnData = unknown, TError = DefaultError>(queryKey: QueryKey): QueryState<TQueryFnData, TError> | undefined;
+    setMutationDefaults(mutationKey: MutationKey, options: Omit<MutationObserverOptions<any, any, any, any>, "mutationKey">): void;
+    setQueryDefaults(queryKey: QueryKey, options: Partial<Omit<QueryObserverOptions<unknown, any, any, any>, "queryKey">>): void;
+    getQueryDefaults(queryKey: QueryKey): QueryObserverOptions<any, any, any, any, any>;
+    removeQueries(filters?: QueryFilters): void;
+    cancelQueries(filters?: QueryFilters, cancelOptions?: CancelOptions): Promise<void>;
+    invalidateQueries(filters?: InvalidateQueryFilters, options?: InvalidateOptions): Promise<void>;
+    resumePausedMutations(): Promise<import("./mutations/mutation/types").MutationState<any, any, any, any>[]>;
+    isFetching(filters?: QueryFilters): number;
+    clear(): void;
+}

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

@@ -0,0 +1,19 @@
+import { BehaviorSubject } from "rxjs";
+export declare class FocusManager {
+    #private;
+    readonly focused$: BehaviorSubject<boolean>;
+    readonly focusRegained$: import("rxjs").Observable<boolean>;
+    constructor();
+    isFocused(): boolean;
+    setFocused(focused?: boolean): void;
+    subscribe(fn: () => void): () => void;
+    /**
+     * @important
+     * You do not need that outside of testing. This is bad practice but necessary in order
+     * to not mess too much with rq tests files.
+     *
+     * Use it after mocking to force the manager to hold mocked value.
+     */
+    refresh(): void;
+}
+export declare const focusManager: FocusManager;

package/dist/lib/queries/client/keys/hashKey.d.ts

@@ -0,0 +1,3 @@
+import { type MutationKey } from "../mutations/types";
+import { type QueryKey } from "./types";
+export declare const hashKey: (queryKey: QueryKey | MutationKey) => string;

package/dist/lib/queries/client/keys/{compareKeys.d.ts → matchKey.d.ts}

@@ -1,4 +1,4 @@
 import { type QueryKey } from "./types";
-export declare const compareKeys: (keyA: QueryKey, keyB: QueryKey, { exact }?: {
+export declare const matchKey: (keyA: QueryKey, keyB: QueryKey, { exact }?: {
     exact?: boolean | undefined;
 }) => boolean;

package/dist/lib/queries/client/keys/partialMatchKey.d.ts

@@ -0,0 +1,5 @@
+import { type QueryKey } from "./types";
+/**
+ * Checks if key `b` partially matches with key `a`.
+ */
+export declare function partialMatchKey(a: QueryKey, b: QueryKey): boolean;

package/dist/lib/queries/client/mutations/cache/MutationCache.d.ts

@@ -1,30 +1,19 @@
-import { type DefaultError } from "@tanstack/react-query";
 import { Mutation } from "../mutation/Mutation";
-import { type QueryClient } from "../../createClient";
+import { type QueryClient } from "../../QueryClient";
 import { type MutationFilters } from "../types";
-import { BehaviorSubject } from "rxjs";
 import { type MutationCacheConfig, type MutationCacheNotifyEvent } from "./types";
 import { type MutationOptions, type MutationState } from "../mutation/types";
+import { type DefaultError } from "../../types";
 export declare class MutationCache {
+    #private;
     config: MutationCacheConfig;
-    protected readonly mutationsSubject: BehaviorSubject<Mutation<any, any, any, any>[]>;
-    protected mutations$: import("rxjs").Observable<Mutation<any, any, any, any>[]>;
-    protected added$: import("rxjs").Observable<Mutation<any, any, any, any>>;
-    protected removed$: import("rxjs").Observable<Mutation<any, any, any, any>>;
-    protected stateChange$: import("rxjs").Observable<Mutation<any, any, any, any>>;
     constructor(config?: MutationCacheConfig);
     build<TData, TError, TVariables, TContext>(client: QueryClient, options: MutationOptions<TData, TError, TVariables, TContext>, state?: MutationState<TData, TError, TVariables, TContext>): Mutation<TData, TError, TVariables, TContext>;
     getAll(): Mutation<any, any, any, any>[];
     remove(mutationToRemove: Mutation<any, any, any, any>): void;
     find<TData = unknown, TError = DefaultError, TVariables = any, TContext = unknown>(filters: MutationFilters<TData, TError, TVariables, TContext>): Mutation<TData, TError, TVariables, TContext> | undefined;
-    findAll(filters?: MutationFilters): Array<Mutation<any, any, any, any>>;
-    observe<TData, MutationStateSelected = MutationState<TData>>({ filters, select }?: {
-        filters?: MutationFilters<TData>;
-        select?: (mutation: Mutation<TData>) => MutationStateSelected;
-    }): {
-        value$: import("rxjs").Observable<MutationStateSelected[]>;
-        lastValue: MutationStateSelected[];
-    };
+    findAll<TData = unknown, TError = Error, TVariables = any, TContext = unknown>(filters?: MutationFilters<TData, TError, TVariables, TContext>): Array<Mutation<any, any, any, any>>;
+    observe(): import("rxjs").Observable<Mutation<any, any, any, any>>;
     /**
      * @important
      * ISO api react-query

package/dist/lib/queries/client/mutations/mutation/Mutation.d.ts

@@ -1,4 +1,4 @@
-import { Subject, type Observable, BehaviorSubject } from "rxjs";
+import { type Observable } from "rxjs";
 import { type DefaultError } from "../../types";
 import { type MutationCache } from "../cache/MutationCache";
 import { type MutationState, type MutationMeta, type MutationOptions } from "./types";
@@ -9,20 +9,15 @@ interface MutationConfig<TData, TError, TVariables, TContext> {
     state?: MutationState<TData, TError, TVariables, TContext>;
 }
 export declare class Mutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
-    protected mutationCache: MutationCache;
-    protected observerCount: BehaviorSubject<number>;
-    protected destroySubject: Subject<void>;
-    protected resetSubject: Subject<void>;
-    protected executeSubject: Subject<TVariables>;
+    #private;
     state: MutationState<TData, TError, TVariables, TContext>;
     state$: Observable<typeof this.state>;
     options: MutationOptions<TData, TError, TVariables, TContext>;
     observerCount$: Observable<number>;
-    destroyed$: Observable<void>;
+    cancelled$: Observable<void>;
     constructor({ options, mutationCache, state }: MutationConfig<TData, TError, TVariables, TContext>);
     get meta(): MutationMeta | undefined;
     setOptions(options?: MutationOptions<TData, TError, TVariables, TContext>): void;
-    observeTillFinished(): Observable<MutationState<TData, TError, TVariables, TContext>>;
     /**
      * @important
      * The resulting observable will complete as soon as the mutation
@@ -30,7 +25,6 @@ export declare class Mutation<TData = unknown, TError = DefaultError, TVariables
      */
     execute(variables: TVariables): Observable<MutationState<TData, TError, TVariables, TContext>>;
     continue(): Observable<MutationState<TData, TError, TVariables, TContext>>;
-    destroy(): void;
-    reset(): void;
+    cancel(): void;
 }
 export {};

package/dist/lib/queries/client/mutations/mutation/delayWhenNetworkOnline.d.ts

@@ -0,0 +1,4 @@
+import { type Observable } from "rxjs";
+export declare const delayWhenNetworkOnline: <T extends {
+    isPaused?: boolean | undefined;
+}>() => (source: Observable<T>) => Observable<T>;

package/dist/lib/queries/client/mutations/mutation/observeUntilFinished.d.ts

@@ -0,0 +1,3 @@
+import { type Observable } from "rxjs";
+import { type MutationState } from "./types";
+export declare const observeUntilFinished: <T extends MutationState<any, any, any, any>>(source: Observable<T>) => Observable<T>;

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

@@ -1,5 +1,5 @@
 import { type Observable, type MonoTypeOperatorFunction } from "rxjs";
-import { type DefaultError, type Query, type QueryResult, type Register } from "../../types";
+import { type DefaultError, type DeprecatedQuery, type QueryResult, type Register } from "../../types";
 import { type MapOperator, type MutationFn, type MutationKey } from "../types";
 export type MutationStatus = "idle" | "pending" | "success" | "error";
 export interface MutationState<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> {
@@ -15,8 +15,9 @@ export interface MutationState<TData = unknown, TError = unknown, TVariables = v
 }
 export type MutationMeta = Register extends {
     mutationMeta: infer TMutationMeta;
-} ? TMutationMeta : Record<string, unknown>;
+} ? TMutationMeta extends Record<string, unknown> ? TMutationMeta : Record<string, unknown> : Record<string, unknown>;
 export interface MutationOptions<TData, TError = DefaultError, TVariables = void, TContext = unknown> {
+    networkMode?: "offlineFirst";
     enabled?: boolean;
     retry?: false | number | ((attempt: number, error: unknown) => boolean);
     retryDelay?: number | ((failureCount: number, error: TError) => number);
@@ -36,7 +37,7 @@ export interface MutationOptions<TData, TError = DefaultError, TVariables = void
      * interval is paused until the query finish fetching. This avoid infinite
      * loop of refetch
      */
-    refetchInterval?: number | false | ((data: QueryResult<TData>["data"] | undefined, query: Query) => number | false);
+    refetchInterval?: number | false | ((data: QueryResult<TData>["data"] | undefined, query: DeprecatedQuery) => number | false);
     terminateOnFirstResult?: boolean;
     onMutate?: (variables: TVariables) => Promise<TContext | undefined> | Observable<TContext | undefined> | TContext | undefined;
     onError?: (error: TError, variables: TVariables, context: TContext | undefined) => Promise<unknown> | unknown;

package/dist/lib/queries/client/mutations/mutation/waitForNetworkOnError.d.ts

@@ -0,0 +1,6 @@
+import { type Observable } from "rxjs";
+export declare const waitForNetworkOnError: <T extends {
+    failureCount?: number | undefined;
+    failureReason?: any;
+    isPaused?: boolean | undefined;
+}>(source: Observable<T>) => Observable<T>;

package/dist/lib/queries/client/mutations/observers/MutationObserver.d.ts

@@ -1,6 +1,6 @@
 import { type Observable } from "rxjs";
 import { type MutateOptions } from "../types";
-import { type QueryClient } from "../../createClient";
+import { type QueryClient } from "../../QueryClient";
 import { type DefaultError } from "../../types";
 import { type MutationObserverOptions, type MutationObserverResult } from "./types";
 import { MutationRunner } from "../runner/MutationRunner";
@@ -13,8 +13,6 @@ export declare class MutationObserver<TData = unknown, TError = DefaultError, TV
     #private;
     protected client: QueryClient;
     protected options: MutationObserverOptions<TData, TError, TVariables, TContext>;
-    protected numberOfObservers: number;
-    protected mutationRunner: MutationRunner<any, any, any, TContext>;
     /**
      * @important
      * Used to maintain persistance to latest mutation. This ensure
@@ -22,10 +20,6 @@ export declare class MutationObserver<TData = unknown, TError = DefaultError, TV
      * - mutation mutate options are run on finish
      */
     readonly observed$: Observable<never>;
-    readonly result$: Observable<{
-        state: MutationObserverResult<TData, TError, TVariables, TContext>;
-        options: MutateOptions<TData, TError, TVariables, TContext> | undefined;
-    }>;
     constructor(client: QueryClient, options?: MutationObserverOptions<TData, TError, TVariables, TContext>, mutationRunner?: MutationRunner<any, any, any, TContext>);
     setOptions(options: MutationObserverOptions<TData, TError, TVariables, TContext>): void;
     protected getObserverResultFromState: (state: MutationState<any, any, any, any>) => MutationObserverResult<TData, TError, TVariables, TContext>;

package/dist/lib/queries/client/mutations/runner/MutationRunner.d.ts

@@ -1,15 +1,17 @@
-import { type ObservedValueOf, Subject, type Observable } from "rxjs";
+import { type Observable } from "rxjs";
 import { type DefaultError } from "../../types";
 import { type MutationObserverOptions } from "../observers/types";
 import { type Mutation } from "../mutation/Mutation";
 import { type MutationOptions, type MutationState } from "../mutation/types";
+interface TriggerSubject<TData, TError = DefaultError, TVariables = void, TContext = unknown> {
+    args: TVariables;
+    options: MutationOptions<TData, TError, TVariables, TContext>;
+    mutation: Mutation<TData, TError, TVariables, TContext>;
+}
 export declare class MutationRunner<TData, TError = DefaultError, TVariables = void, TContext = unknown> {
-    protected trigger$: Subject<{
-        args: TVariables;
-        options: MutationOptions<TData, TError, TVariables, TContext>;
-        mutation: Mutation<TData, TError, TVariables, TContext>;
-    }>;
+    #private;
     state$: Observable<MutationState<TData, TError, TVariables, TContext>>;
     constructor({ __queryFinalizeHook }?: MutationObserverOptions<TData, TError, TVariables, TContext>);
-    trigger({ args, options, mutation }: ObservedValueOf<typeof this.trigger$>): void;
+    trigger({ args, options, mutation }: TriggerSubject<TData, TError, TVariables, TContext>): void;
 }
+export {};

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

@@ -0,0 +1,10 @@
+import { BehaviorSubject } from "rxjs";
+export declare class OnlineManager {
+    protected isOnlineSubject: BehaviorSubject<boolean>;
+    readonly online$: import("rxjs").Observable<boolean>;
+    readonly backToOnline$: import("rxjs").Observable<boolean>;
+    constructor();
+    isOnline(): boolean;
+    setOnline(online: boolean): void;
+}
+export declare const onlineManager: OnlineManager;

package/dist/lib/queries/client/queries/cache/QueryCache.d.ts

@@ -0,0 +1,33 @@
+import { type DefaultError } from "../../types";
+import { type QueryKey } from "../../keys/types";
+import { Query } from "../query/Query";
+import { type QueryOptions, type QueryFilters } from "../types";
+import { type QueryClient } from "../../QueryClient";
+import { type QueryState } from "../query/types";
+import { type WithRequired } from "../../../../utils/types";
+import { type QueryCacheConfig, type QueryCacheListener } from "./types";
+export interface QueryStore {
+    has: (queryHash: string) => boolean;
+    set: (queryHash: string, query: Query) => void;
+    get: (queryHash: string) => Query | undefined;
+    delete: (queryHash: string) => void;
+    values: () => IterableIterator<Query>;
+}
+export declare class QueryCache {
+    #private;
+    config: QueryCacheConfig;
+    constructor(config?: QueryCacheConfig);
+    mount(): void;
+    unmount(): void;
+    notify(event: Parameters<QueryCacheListener>[0]): void;
+    observeIsFetching(filters?: QueryFilters): import("rxjs").Observable<number>;
+    getAll(): Query[];
+    findAll(filters?: QueryFilters): Query[];
+    build<TQueryFnData, TError, TData, TQueryKey extends QueryKey>(client: QueryClient, options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>, state?: QueryState<TData, TError>): Query<TQueryFnData, TError, TData, TQueryKey>;
+    add(query: Query<any, any, any, any>): void;
+    get<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryHash: string): Query<TQueryFnData, TError, TData, TQueryKey> | undefined;
+    find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(filters: WithRequired<QueryFilters, "queryKey">): Query<TQueryFnData, TError, TData> | undefined;
+    subscribe(fn: QueryCacheListener): () => void;
+    remove(query: Query<any, any, any, any>): void;
+    clear(): void;
+}

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

@@ -0,0 +1,45 @@
+import { type NotifyEvent } from "../../mutations/cache/types";
+import { type DefaultError } from "../../types";
+import { type QueryObserver } from "../observer/QueryObserver";
+import { type Query } from "../query/Query";
+import { type Action } from "../query/types";
+export interface QueryCacheConfig {
+    onError?: (error: DefaultError, query: Query<unknown, unknown, unknown>) => void;
+    onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void;
+    onSettled?: (data: unknown | undefined, error: DefaultError | null, query: Query<unknown, unknown, unknown>) => void;
+}
+interface NotifyEventQueryAdded extends NotifyEvent {
+    type: "added";
+    query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryRemoved extends NotifyEvent {
+    type: "removed";
+    query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryUpdated extends NotifyEvent {
+    type: "updated";
+    query: Query<any, any, any, any>;
+    action: Action<any, any>;
+}
+interface NotifyEventQueryObserverAdded extends NotifyEvent {
+    type: "observerAdded";
+    query: Query<any, any, any, any>;
+    observer: QueryObserver<any, any, any, any, any>;
+}
+interface NotifyEventQueryObserverRemoved extends NotifyEvent {
+    type: "observerRemoved";
+    query: Query<any, any, any, any>;
+    observer: QueryObserver<any, any, any, any, any>;
+}
+interface NotifyEventQueryObserverResultsUpdated extends NotifyEvent {
+    type: "observerResultsUpdated";
+    query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryObserverOptionsUpdated extends NotifyEvent {
+    type: "observerOptionsUpdated";
+    query: Query<any, any, any, any>;
+    observer: QueryObserver<any, any, any, any, any>;
+}
+export type QueryCacheNotifyEvent = NotifyEventQueryAdded | NotifyEventQueryRemoved | NotifyEventQueryUpdated | NotifyEventQueryObserverAdded | NotifyEventQueryObserverRemoved | NotifyEventQueryObserverResultsUpdated | NotifyEventQueryObserverOptionsUpdated;
+export type QueryCacheListener = (event: QueryCacheNotifyEvent) => void;
+export {};

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

@@ -0,0 +1,65 @@
+import { type Observable, Subject } from "rxjs";
+import { type QueryClient } from "../../QueryClient";
+import { type QueryKey } from "../../keys/types";
+import { type DefaultError } from "../../types";
+import { type Query } from "../query/Query";
+import { type FetchOptions } from "../query/types";
+import { type RefetchOptions } from "../types";
+import { type QueryObserverResult, type QueryObserverOptions, type DefaultedQueryObserverOptions, type QueryObserverListener } from "./types";
+export interface ObserverFetchOptions extends FetchOptions {
+    throwOnError?: boolean;
+}
+export interface NotifyOptions {
+    listeners?: boolean;
+}
+interface LastResult<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey = QueryKey> {
+    state: Query<TQueryFnData, TError, TQueryData, TQueryKey>["state"];
+    result: QueryObserverResult<TData, TError>;
+    options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+    selectResult?: TData;
+    selectError?: null | TError;
+    select?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>["select"] | null;
+}
+export declare class QueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+    #private;
+    options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+    /**
+     * Used to subscribe to changes in either query or options (or both).
+     * We need to be able to track change to both of them at the same time
+     * in order to react accordingly and in order (such as refetch on options change)
+     */
+    readonly queryUpdateSubject: Subject<{
+        options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+    }>;
+    constructor(client: QueryClient, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
+    protected bindMethods(): void;
+    setOptions(options?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+    protected buildQuery(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+    protected getObserverResultFromQuery: ({ options, query, optimisticResult, prevResult: { result: prevResult, options: prevResultOptions, state: prevResultState, select: prevSelect, selectError: prevSelectError, selectResult: prevSelectResult } }: {
+        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+        options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+        optimisticResult?: boolean | undefined;
+        prevResult: Partial<LastResult<TQueryFnData, TError, TData, TQueryData, TQueryKey>>;
+    }) => {
+        result: QueryObserverResult<TData, TError>;
+        selectError: TError | null | undefined;
+        select: ((data: TQueryData) => TData) | null;
+        selectResult: TData | undefined;
+    };
+    getCurrentResult(): QueryObserverResult<TData, TError>;
+    getCurrentQuery(): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+    getOptimisticResult(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
+    protected updateResult({ query, result, selectError, select, selectResult }: Pick<LastResult<TQueryFnData, TError, TData, TQueryData, TQueryKey>, "select" | "selectError" | "result" | "selectResult"> & {
+        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+    }): void;
+    refetch({ ...options }?: RefetchOptions): Promise<QueryObserverResult<TData, TError>>;
+    protected fetch(fetchOptions?: ObserverFetchOptions): Promise<QueryObserverResult<TData, TError>>;
+    /**
+     * feature parity with rq, not used internally
+     */
+    subscribe(listener: QueryObserverListener<TData, TError>): () => void;
+    observe(): Observable<QueryObserverResult<TData, TError>>;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,9 @@
+import { type Query } from "../query/Query";
+import { type NetworkMode } from "../types";
+import { type QueryObserverOptions } from "./types";
+export declare function isStale(query: Query<any, any, any, any>, options: QueryObserverOptions<any, any, any, any, any>): boolean;
+export declare function shouldFetchOnMount(query: Query<any, any, any, any>, options: QueryObserverOptions<any, any, any, any, any>): boolean;
+export declare function shouldFetchOptionally(query: Query<any, any, any, any>, prevQuery: Query<any, any, any, any>, options: QueryObserverOptions<any, any, any, any, any>, prevOptions: QueryObserverOptions<any, any, any, any, any>): boolean;
+export declare function shouldFetchOnWindowFocus(query: Query<any, any, any, any>, options: QueryObserverOptions<any, any, any, any, any>): boolean;
+export declare function shouldFetchOn(query: Query<any, any, any, any>, options: QueryObserverOptions<any, any, any, any, any>, field: (typeof options)["refetchOnMount"] & (typeof options)["refetchOnWindowFocus"] & (typeof options)["refetchOnReconnect"]): boolean;
+export declare function canFetch(networkMode: NetworkMode | undefined): boolean;