reactjrx 1.62.0 → 1.65.0

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

@@ -1,7 +1,10 @@
 import { type Observable, BehaviorSubject } from "rxjs";
 import { type QueryOptions, type QueryFn, type QueryTrigger, type QueryResult } from "./types";
 import { type QueryKey } from "./keys/types";
-import { MutationClient } from "./mutations/MutationClient";
+import { MutationRunners } from "./mutations/runners/MutationRunners";
+import { type MutationOptions } from "./mutations/types";
+import { MutationCache } from "./mutations/cache/MutationCache";
+import { MutationObserver } from "./mutations/observers/MutationObserver";
 export declare const createClient: () => {
     destroy: () => void;
     pipeQueryResult: <R extends Partial<QueryResult<T>>, T>({ options$ }: {
@@ -69,9 +72,17 @@ export declare const createClient: () => {
         size: () => number;
         start: () => () => void;
     };
-    mutationClient: MutationClient;
 };
 export declare class QueryClient {
     client: ReturnType<typeof createClient>;
-    constructor();
+    protected mutationCache: MutationCache;
+    mutationRunners: MutationRunners;
+    mutationObserver: MutationObserver;
+    constructor({ mutationCache }?: {
+        mutationCache: MutationCache;
+    });
+    mount(): () => void;
+    getMutationCache(): MutationCache;
+    defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(options?: T): T;
+    clear(): void;
 }

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

@@ -1,15 +1,27 @@
-import { type Observable, ReplaySubject } from "rxjs";
+import { Subject, Observable, BehaviorSubject } from "rxjs";
 import { type MutationState, type MutationOptions } from "./types";
-export declare class Mutation<Data> {
-    stateSubject: ReplaySubject<MutationState<Data, unknown, void, unknown>>;
+import { type DefaultError } from "../types";
+import { type MutationCache } from "./cache/MutationCache";
+export declare class Mutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    state: MutationState<TData, TError, TVariables, TContext>;
+    state$: Observable<typeof this.state>;
+    options: MutationOptions<TData, TError, TVariables, TContext>;
+    mutationCache: MutationCache;
+    protected observerCount: BehaviorSubject<number>;
+    observerCount$: Observable<number>;
+    protected cancelSubject: Subject<void>;
+    protected executeSubject: Subject<TVariables>;
+    constructor({ options, mutationCache }: {
+        mutationCache: MutationCache;
+        options: MutationOptions<TData, TError, TVariables, TContext>;
+    });
+    createMutation(variables: TVariables): Observable<MutationState<TData, TError, TVariables, TContext>>;
+    observeTillFinished(): Observable<MutationState<TData, TError, TVariables, TContext>>;
     /**
      * @important
-     * convenience over usage of stateSubject for sync access
+     * The resulting observable will complete as soon as the mutation
+     * is over, unlike the state which can be re-subscribed later.
      */
-    state: MutationState<Data>;
-    options: MutationOptions<Data, any>;
-    mutation$: Observable<MutationState<Data>>;
-    constructor({ args, ...options }: {
-        args: any;
-    } & MutationOptions<Data, any>);
+    execute(variables: TVariables): Observable<MutationState<TData, TError, TVariables, TContext>>;
+    cancel(): void;
 }

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

@@ -0,0 +1,43 @@
+import { type DefaultError } from "@tanstack/react-query";
+import { Mutation } from "../Mutation";
+import { type QueryClient } from "../../createClient";
+import { type MutationFilters, type MutationOptions, type MutationState } from "../types";
+import { BehaviorSubject, type Subscription } from "rxjs";
+import { type MutationCacheNotifyEvent } from "./types";
+interface MutationCacheConfig {
+    onError?: <Data = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(error: DefaultError, variables: unknown, context: unknown, mutation: Mutation<Data, TError, TVariables, TContext>) => Promise<unknown> | unknown;
+    onSuccess?: (data: unknown, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => Promise<unknown> | unknown;
+    onMutate?: (variables: unknown, mutation: Mutation<unknown, unknown, unknown>) => Promise<unknown> | unknown;
+    onSettled?: (data: unknown | undefined, error: DefaultError | null, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => Promise<unknown> | unknown;
+}
+export declare class MutationCache {
+    config: MutationCacheConfig;
+    protected readonly mutationsSubject: BehaviorSubject<{
+        mutation: Mutation<any, any, any, any>;
+        sub: Subscription;
+    }[]>;
+    mutations$: import("rxjs").Observable<Mutation<any, any, any, any>[]>;
+    added$: import("rxjs").Observable<Mutation<any, any, any, any>>;
+    removed$: import("rxjs").Observable<Mutation<any, any, any, any>>;
+    stateChange$: import("rxjs").Observable<Mutation<any, any, any, any>>;
+    constructor(config?: MutationCacheConfig);
+    subscribe(listener: (event: MutationCacheNotifyEvent) => void): () => void;
+    build<TData, TError, TVariables, TContext>(client: QueryClient, options: MutationOptions<TData, TError, TVariables, TContext>): Mutation<TData, TError, TVariables, TContext>;
+    getAll(): Mutation<any, any, any, any>[];
+    remove(mutation: Mutation<any, any, any, any>): void;
+    removeBy<TData = unknown, TError = DefaultError, TVariables = any, TContext = unknown>(filters: MutationFilters<TData, TError, TVariables, TContext>): void;
+    find<TData = unknown, TError = DefaultError, TVariables = any, TContext = unknown>(filters: MutationFilters<TData, TError, TVariables, TContext>): Mutation<TData, TError, TVariables, TContext> | undefined;
+    findLatest<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>>;
+    mutationsBy<TData = unknown, TError = DefaultError, TVariables = any, TContext = unknown>(filters: MutationFilters<TData, TError, TVariables, TContext>): import("rxjs").Observable<Mutation<any, any, any, any>[]>;
+    mutationStateBy<TData, MutationStateSelected = MutationState<TData>>({ filters, select }?: {
+        filters?: MutationFilters<TData>;
+        select?: (mutation: Mutation<TData>) => MutationStateSelected;
+    }): {
+        value$: import("rxjs").Observable<MutationStateSelected[]>;
+        lastValue: MutationStateSelected[];
+    };
+    cancelBy(filters: MutationFilters): void;
+    clear(): void;
+}
+export {};

package/dist/lib/queries/client/mutations/cache/mutationCache.test.d.ts

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

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

@@ -0,0 +1,61 @@
+import { type Mutation } from "../Mutation";
+import { type MutationObserver } from "../observers/MutationObserver";
+export type NotifyEventType = "added" | "removed" | "updated" | "observerAdded" | "observerRemoved" | "observerResultsUpdated" | "observerOptionsUpdated";
+export interface NotifyEvent {
+    type: NotifyEventType;
+}
+interface FailedAction<TError> {
+    type: "failed";
+    failureCount: number;
+    error: TError | null;
+}
+interface PendingAction<TVariables, TContext> {
+    type: "pending";
+    variables?: TVariables;
+    context?: TContext;
+}
+interface SuccessAction<TData> {
+    type: "success";
+    data: TData;
+}
+interface ErrorAction<TError> {
+    type: "error";
+    error: TError;
+}
+interface PauseAction {
+    type: "pause";
+}
+interface ContinueAction {
+    type: "continue";
+}
+export type Action<TData, TError, TVariables, TContext> = ContinueAction | ErrorAction<TError> | FailedAction<TError> | PendingAction<TVariables, TContext> | PauseAction | SuccessAction<TData>;
+interface NotifyEventMutationAdded extends NotifyEvent {
+    type: "added";
+    mutation: Mutation<any, any, any, any>;
+}
+interface NotifyEventMutationRemoved extends NotifyEvent {
+    type: "removed";
+    mutation: Mutation<any, any, any, any>;
+}
+interface NotifyEventMutationObserverAdded extends NotifyEvent {
+    type: "observerAdded";
+    mutation: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any>;
+}
+interface NotifyEventMutationObserverRemoved extends NotifyEvent {
+    type: "observerRemoved";
+    mutation: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any>;
+}
+interface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {
+    type: "observerOptionsUpdated";
+    mutation?: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any, any>;
+}
+interface NotifyEventMutationUpdated extends NotifyEvent {
+    type: "updated";
+    mutation: Mutation<any, any, any, any>;
+    action: Action<any, any, any, any>;
+}
+export type MutationCacheNotifyEvent = NotifyEventMutationAdded | NotifyEventMutationRemoved | NotifyEventMutationObserverAdded | NotifyEventMutationObserverRemoved | NotifyEventMutationObserverOptionsUpdated | NotifyEventMutationUpdated;
+export {};

package/dist/lib/queries/client/mutations/defaultMutationState.d.ts

@@ -1,2 +1,2 @@
 import { type MutationState } from "./types";
-export declare const getDefaultMutationState: <TData>() => MutationState<TData, unknown, void, unknown>;
+export declare const getDefaultMutationState: <TData = unknown, TError = unknown, TVariables = void, TContext = unknown>() => MutationState<TData, TError, TVariables, TContext>;

package/dist/lib/queries/client/mutations/filters.d.ts

@@ -1,2 +1,2 @@
 import { type MutationFilters } from "./types";
-export declare const createPredicateForFilters: <TData>({ mutationKey, status, predicate }?: MutationFilters<TData>) => (mutation: import("./Mutation").Mutation<TData>) => boolean;
+export declare const createPredicateForFilters: <TData = unknown, TError = Error, TVariables = any, TContext = unknown>({ mutationKey, status, predicate, exact }?: MutationFilters<TData, TError, TVariables, TContext>) => (mutation: import("./Mutation").Mutation<TData, TError, TVariables, TContext>) => boolean;

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

@@ -0,0 +1,25 @@
+import { type Observable } from "rxjs";
+import { type MutationOptions, type MutateOptions, type MutationState, type MutationFilters } from "../types";
+import { type QueryClient } from "../../createClient";
+import { type DefaultError } from "../../types";
+import { type Mutation } from "../Mutation";
+import { type MutationObserverResult } from "./types";
+/**
+ * Provide API to observe mutations results globally.
+ * Observe runners and map their results in a hash map.
+ */
+export declare class MutationObserver<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    protected client: QueryClient;
+    protected options?: Partial<MutationOptions<TData, TError, TVariables, TContext>> | undefined;
+    constructor(client: QueryClient, options?: Partial<MutationOptions<TData, TError, TVariables, TContext>> | undefined);
+    protected getDerivedState: (state: MutationState<any, any, any, any>) => MutationObserverResult;
+    observeBy<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(filters: MutationFilters): {
+        result$: Observable<MutationObserverResult<TData, TError, TVariables, TContext>>;
+        lastValue: MutationObserverResult<TData, TError, TVariables, TContext>;
+    };
+    observe(mutation: Mutation): Observable<MutationState<unknown, Error, void, unknown>>;
+    subscribe(subscription: () => void): () => void;
+    mutate(variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>): Promise<MutationState<TData, TVariables, void, unknown>>;
+    reset(): void;
+    destroy(): void;
+}

package/dist/lib/queries/client/mutations/observers/mutationObserver.test.d.ts

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

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

@@ -0,0 +1,59 @@
+import { type DefaultError } from "../../types";
+import { type MutationState, type MutationStatus } from "../types";
+export interface MutationObserverBaseResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationState<TData, TError, TVariables, TContext> {
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+}
+export interface MutationObserverIdleResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+}
+export interface MutationObserverLoadingResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+    data: undefined;
+    variables: TVariables;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+}
+export interface MutationObserverErrorResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+    data: undefined;
+    error: TError;
+    variables: TVariables;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+}
+export interface MutationObserverSuccessResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+    data: TData;
+    error: null;
+    variables: TVariables;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+}
+export interface MutationObserverAnyResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+    data: TData | undefined;
+    error: TError | null;
+    variables: TVariables;
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    status: MutationStatus;
+}
+export type MutationObserverResult<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = MutationObserverAnyResult<TData, TError, TVariables, TContext>;

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

@@ -1,3 +1,3 @@
 import { type Observable } from "rxjs";
 import { type MutationState } from "./types";
-export declare const mergeResults: <T>(stream$: Observable<Partial<MutationState<T, unknown, void, unknown>>>) => Observable<MutationState<T, unknown, void, unknown>>;
+export declare const mergeResults: <TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown>(stream$: Observable<Partial<MutationState<TData, TError, TVariables, TContext>>>) => Observable<MutationState<TData, TError, TVariables, TContext>>;

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

@@ -0,0 +1,19 @@
+import { Subject } from "rxjs";
+import { type MutationOptions } from "../types";
+import { type MutationCache } from "../cache/MutationCache";
+import { type QueryClient } from "../../createClient";
+export type MutationRunner = ReturnType<typeof createMutationRunner>;
+export declare const createMutationRunner: <TData, TError = Error, MutationArg = void, TContext = unknown>({ __queryFinalizeHook, __queryInitHook, __queryTriggerHook, mutationKey, mutationCache, }: {
+    mutationCache: MutationCache;
+    client: QueryClient;
+} & Pick<MutationOptions<TData, TError, MutationArg, TContext>, "__queryInitHook" | "__queryTriggerHook" | "__queryFinalizeHook" | "mutationKey">) => {
+    mutationKey: import("../types").MutationKey;
+    runner$: import("rxjs").Observable<import("../types").MutationState<unknown, unknown, unknown, unknown>>;
+    trigger: ({ args, options }: {
+        args: MutationArg;
+        options: MutationOptions<TData, TError, MutationArg, TContext>;
+    }) => void;
+    cancel$: Subject<void>;
+    destroy: () => void;
+    getClosed: () => boolean;
+};

package/dist/lib/queries/client/mutations/runners/MutationRunners.d.ts

@@ -0,0 +1,54 @@
+import { BehaviorSubject } from "rxjs";
+import { type MutationOptions } from "../types";
+import { createMutationRunner } from "./MutationRunner";
+import { type QueryClient } from "../../createClient";
+import { type DefaultError } from "../../types";
+export declare class MutationRunners {
+    client: QueryClient;
+    /**
+     * Contain all active mutation for a given key.
+     * A mutation ca have several triggers running (it is not necessarily one function running)
+     *
+     * @important
+     * - automatically cleaned as soon as the last mutation is done for a given key
+     */
+    mutationRunnersByKey$: BehaviorSubject<Map<string, {
+        mutationKey: import("../types").MutationKey;
+        runner$: import("rxjs").Observable<import("../types").MutationState<unknown, unknown, unknown, unknown>>;
+        trigger: ({ args, options }: {
+            args: any;
+            options: MutationOptions<any, any, any, any>;
+        }) => void;
+        cancel$: import("rxjs").Subject<void>;
+        destroy: () => void;
+        getClosed: () => boolean;
+    }>>;
+    constructor(client: QueryClient);
+    /**
+     * @helper
+     */
+    setMutationRunnersByKey(key: string, value: ReturnType<typeof createMutationRunner>): void;
+    /**
+     * @helper
+     */
+    deleteMutationRunnersByKey(key: string): void;
+    /**
+     * @helper
+     */
+    getMutationRunnersByKey(key: string): {
+        mutationKey: import("../types").MutationKey;
+        runner$: import("rxjs").Observable<import("../types").MutationState<unknown, unknown, unknown, unknown>>;
+        trigger: ({ args, options }: {
+            args: any;
+            options: MutationOptions<any, any, any, any>;
+        }) => void;
+        cancel$: import("rxjs").Subject<void>;
+        destroy: () => void;
+        getClosed: () => boolean;
+    } | undefined;
+    mutate<TData, TError = DefaultError, TVariables = void, TContext = unknown>(params: {
+        options: MutationOptions<TData, TError, TVariables, TContext>;
+        args: TVariables;
+    }): Promise<import("../types").MutationState<TData, TError, TVariables, TContext>>;
+    destroy(): void;
+}

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

@@ -26,14 +26,15 @@ export type MutationKey = unknown[];
 /**
  * @todo this should be used in a lot of place so we can probably make a helper for that
  */
-export interface MutationFilters<TData> {
+export interface MutationFilters<TData = unknown, TError = DefaultError, TVariables = any, TContext = unknown> {
     /**
      * Match mutation key exactly
      */
+    exact?: boolean;
     /**
      * Include mutations matching this predicate function
      */
-    predicate?: (mutation: Mutation<TData>) => boolean;
+    predicate?: (mutation: Mutation<TData, TError, TVariables, TContext>) => boolean;
     /**
      * Include mutations matching this mutation key
      */
@@ -44,9 +45,10 @@ export interface MutationFilters<TData> {
     status?: MutationStatus;
 }
 export type MutationFn<Data, MutationArg> = Observable<Data> | ((arg: MutationArg) => Promise<Data>) | ((arg: MutationArg) => Observable<Data>);
-export interface MutationOptions<Result, MutationArg> {
+export interface MutationOptions<TData, TError = DefaultError, TVariables = void, TContext = unknown> {
     enabled?: boolean;
     retry?: false | number | ((attempt: number, error: unknown) => boolean);
+    gcTime?: number;
     /**
      * @important
      * The hook with the lowest value will be taken into account
@@ -62,17 +64,19 @@ export interface MutationOptions<Result, MutationArg> {
      * interval is paused until the query finish fetching. This avoid infinite
      * loop of refetch
      */
-    refetchInterval?: number | false | ((data: QueryResult<Result>["data"] | undefined, query: Query) => number | false);
+    refetchInterval?: number | false | ((data: QueryResult<TData>["data"] | undefined, query: Query) => number | false);
     terminateOnFirstResult?: boolean;
-    onError?: (error: unknown, arg: MutationArg) => void;
-    onSuccess?: (data: Result, arg: MutationArg) => void;
-    mutationFn: MutationFn<Result, MutationArg>;
+    onMutate?: (variables: TVariables) => Promise<TContext | undefined> | TContext | undefined;
+    onError?: (error: TError, variables: TVariables, context: TContext | undefined) => Promise<unknown> | unknown;
+    onSuccess?: (data: TData, variables: TVariables, context: TContext | undefined) => Promise<unknown> | unknown;
+    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context: TContext | undefined) => Promise<unknown> | unknown;
+    mutationFn: MutationFn<TData, TVariables>;
     mutationKey: MutationKey;
     mapOperator?: MapOperator;
     __queryInitHook?: MonoTypeOperatorFunction<any>;
     __queryRunnerHook?: MonoTypeOperatorFunction<any>;
-    __queryTriggerHook?: MonoTypeOperatorFunction<Partial<Result>>;
-    __queryFinalizeHook?: MonoTypeOperatorFunction<Partial<Result>>;
+    __queryTriggerHook?: MonoTypeOperatorFunction<Partial<TData>>;
+    __queryFinalizeHook?: MonoTypeOperatorFunction<Partial<TData>>;
 }
 export interface MutationState<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> {
     context: TContext | undefined;
@@ -88,60 +92,3 @@ export interface MutateOptions<TData = unknown, TError = DefaultError, TVariable
     onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context: TContext | undefined) => void;
 }
 export type MutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>) => Promise<TData>;
-export interface MutationObserverBaseResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationState<TData, TError, TVariables, TContext> {
-    isError: boolean;
-    isIdle: boolean;
-    isPending: boolean;
-    isSuccess: boolean;
-}
-export interface MutationObserverIdleResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
-    data: undefined;
-    variables: undefined;
-    error: null;
-    isError: false;
-    isIdle: true;
-    isPending: false;
-    isSuccess: false;
-    status: "idle";
-}
-export interface MutationObserverLoadingResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
-    data: undefined;
-    variables: TVariables;
-    error: null;
-    isError: false;
-    isIdle: false;
-    isPending: true;
-    isSuccess: false;
-    status: "pending";
-}
-export interface MutationObserverErrorResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
-    data: undefined;
-    error: TError;
-    variables: TVariables;
-    isError: true;
-    isIdle: false;
-    isPending: false;
-    isSuccess: false;
-    status: "error";
-}
-export interface MutationObserverSuccessResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
-    data: TData;
-    error: null;
-    variables: TVariables;
-    isError: false;
-    isIdle: false;
-    isPending: false;
-    isSuccess: true;
-    status: "success";
-}
-export interface MutationObserverAnyResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
-    data: TData | undefined;
-    error: TError | null;
-    variables: TVariables;
-    isError: boolean;
-    isIdle: boolean;
-    isPending: boolean;
-    isSuccess: boolean;
-    status: MutationStatus;
-}
-export type MutationObserverResult<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = MutationObserverAnyResult<TData, TError, TVariables, TContext>;

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

@@ -0,0 +1,4 @@
+import { type QueryClient } from "../createClient";
+import { type MutationOptions } from "../mutations/types";
+export declare function queryKey(): string[];
+export declare const executeMutation: <TVariables>(queryClient: QueryClient, options: MutationOptions<any, any, TVariables, any>, variables: TVariables) => Promise<import("../mutations/types").MutationState<any, any, TVariables, any>>;

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

@@ -0,0 +1,2 @@
+import { Observable } from "rxjs";
+export declare const functionAsObservable: <Data>(fn: () => Data | Observable<Data> | Promise<Data>) => Observable<Data>;

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

@@ -0,0 +1,3 @@
+type FuncWithArgs<T extends any[], R> = (...args: T) => R;
+export declare function wrapFnInPromise<T extends any[], R>(func: FuncWithArgs<T, R> | FuncWithArgs<T, Promise<R>>, ...args: T): Promise<R>;
+export {};

package/dist/lib/queries/react/Provider.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from "react";
-import { type QueryClient, type createClient } from "../client/createClient";
+import { type QueryClient } from "../client/createClient";
 export declare const Context: import("react").Context<{
-    client: ReturnType<typeof createClient>;
+    client: QueryClient;
 }>;
 export declare const QueryClientProvider: import("react").MemoExoticComponent<({ children, client }: {
     children: ReactNode;
@@ -9,72 +9,4 @@ export declare const QueryClientProvider: import("react").MemoExoticComponent<({
 }) => import("react/jsx-runtime").JSX.Element>;
 export declare const useQueryClient: ({ unsafe }?: {
     unsafe?: boolean | undefined;
-}) => {
-    destroy: () => void;
-    pipeQueryResult: <R extends Partial<import("../client/types").QueryResult<T>>, T>({ options$ }: {
-        key: string;
-        queryStore: {
-            set: (key: string, value: import("../client/store/createQueryStore").StoreObject<unknown>) => void;
-            get: <T_1>(serializedKey: string) => import("../client/store/createQueryStore").StoreObject<T_1> | undefined;
-            get$: (key: string) => import("rxjs").Observable<import("../client/store/createQueryStore").StoreObject<unknown>>;
-            delete: (key: string) => void;
-            update: <T_2>(key: string, value: Partial<import("../client/store/createQueryStore").StoreObject<T_2>> | ((value: import("../client/store/createQueryStore").StoreObject<T_2>) => import("../client/store/createQueryStore").StoreObject<T_2>)) => void;
-            keys: () => IterableIterator<string>;
-            updateMany: (value: Partial<import("../client/store/createQueryStore").StoreObject<unknown>>, predicate?: (storeObject: import("../client/store/createQueryStore").StoreObject<unknown>) => boolean) => void;
-            addRunner: <T_3>(key: string, stream: import("rxjs").Observable<{
-                options: import("../client/types").QueryOptions<T_3>;
-            }>) => () => void;
-            store$: import("rxjs").BehaviorSubject<Map<string, import("rxjs").BehaviorSubject<import("../client/store/createQueryStore").StoreObject<unknown>>>>;
-            queryEvent$: import("rxjs").Observable<import("../client/store/createQueryStore").QueryEvent>;
-            dispatchQueryEvent: (event: import("../client/store/createQueryStore").QueryEvent) => void;
-            queryTrigger$: import("rxjs").Observable<import("../client/store/createQueryStore").QueryTriggerEvent>;
-            dispatchQueryTrigger: (event: import("../client/store/createQueryStore").QueryTriggerEvent) => void;
-            size: () => number;
-            start: () => () => void;
-        };
-        options$: import("rxjs").Observable<import("../client/types").QueryOptions<T>>;
-        refetch$: import("rxjs").Observable<import("../client/types").QueryTrigger>;
-    }) => import("rxjs").MonoTypeOperatorFunction<R>;
-    refetchQueries: (_: {
-        queryKey: import("../client/keys/types").QueryKey;
-    }) => void;
-    setQueryData: ({ queryKey, updater }: {
-        queryKey: import("../client/keys/types").QueryKey;
-        updater: unknown;
-    }) => void;
-    invalidateQueries: ({ queryKey, exact, predicate }?: {
-        queryKey?: import("../client/keys/types").QueryKey | undefined;
-        exact?: boolean | undefined;
-        predicate?: ((storeObject: import("../client/store/createQueryStore").StoreObject<unknown>) => boolean) | undefined;
-    }) => void;
-    start: () => () => void;
-    query: <T_4>({ key, fn$: maybeFn$, fn: maybeFn, trigger$: externalTrigger$, options$ }: {
-        key: import("../client/keys/types").QueryKey;
-        fn?: import("../client/types").QueryFn<T_4> | undefined;
-        fn$?: import("rxjs").Observable<import("../client/types").QueryFn<T_4>> | undefined;
-        trigger$?: import("rxjs").Observable<import("../client/types").QueryTrigger> | undefined;
-        options$?: import("rxjs").Observable<import("../client/types").QueryOptions<T_4>> | undefined;
-    }) => {
-        result$: import("rxjs").Observable<import("../client/types").QueryResult<T_4>>;
-    };
-    queryStore: {
-        set: (key: string, value: import("../client/store/createQueryStore").StoreObject<unknown>) => void;
-        get: <T_1>(serializedKey: string) => import("../client/store/createQueryStore").StoreObject<T_1> | undefined;
-        get$: (key: string) => import("rxjs").Observable<import("../client/store/createQueryStore").StoreObject<unknown>>;
-        delete: (key: string) => void;
-        update: <T_2>(key: string, value: Partial<import("../client/store/createQueryStore").StoreObject<T_2>> | ((value: import("../client/store/createQueryStore").StoreObject<T_2>) => import("../client/store/createQueryStore").StoreObject<T_2>)) => void;
-        keys: () => IterableIterator<string>;
-        updateMany: (value: Partial<import("../client/store/createQueryStore").StoreObject<unknown>>, predicate?: (storeObject: import("../client/store/createQueryStore").StoreObject<unknown>) => boolean) => void;
-        addRunner: <T_3>(key: string, stream: import("rxjs").Observable<{
-            options: import("../client/types").QueryOptions<T_3>;
-        }>) => () => void;
-        store$: import("rxjs").BehaviorSubject<Map<string, import("rxjs").BehaviorSubject<import("../client/store/createQueryStore").StoreObject<unknown>>>>;
-        queryEvent$: import("rxjs").Observable<import("../client/store/createQueryStore").QueryEvent>;
-        dispatchQueryEvent: (event: import("../client/store/createQueryStore").QueryEvent) => void;
-        queryTrigger$: import("rxjs").Observable<import("../client/store/createQueryStore").QueryTriggerEvent>;
-        dispatchQueryTrigger: (event: import("../client/store/createQueryStore").QueryTriggerEvent) => void;
-        size: () => number;
-        start: () => () => void;
-    };
-    mutationClient: import("../client/mutations/MutationClient").MutationClient;
-};
+}) => QueryClient;

package/dist/lib/queries/react/mutations/useIsMutating.d.ts

@@ -1,3 +1,3 @@
 import { type MutationFilters } from "../../client/mutations/types";
 import { type QueryClient } from "../../client/createClient";
-export declare const useIsMutating: <TData>(filters?: MutationFilters<TData>, queryClient?: QueryClient) => number;
+export declare const useIsMutating: <TData>(filters?: MutationFilters<TData, Error, any, unknown>, queryClient?: QueryClient) => number;

package/dist/lib/queries/react/mutations/useMutation.cancel.test.d.ts

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

package/dist/lib/queries/react/mutations/useMutation.d.ts

@@ -1,20 +1,21 @@
 import { type MutationKey, type MutationOptions } from "../../client/mutations/types";
 import { type QueryClient } from "../../client/createClient";
-export type AsyncQueryOptions<Result, Params> = Omit<MutationOptions<Result, Params>, "mutationKey"> & {
+import { type DefaultError } from "../../client/types";
+export type AsyncQueryOptions<Result, Params> = Omit<MutationOptions<Result, Error, Params>, "mutationKey"> & {
     mutationKey?: MutationKey;
     cancelOnUnMount?: boolean;
 };
-export declare function useMutation<Args = void, R = undefined>(options: AsyncQueryOptions<R, Args>, queryClient?: QueryClient): {
-    data: R | undefined;
-    error: unknown;
-    variables: void;
+export declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: AsyncQueryOptions<TData, TVariables>, queryClient?: QueryClient): {
+    data: TData | undefined;
+    error: TError | null;
+    variables: TVariables;
     isError: boolean;
     isIdle: boolean;
     isPending: boolean;
     isSuccess: boolean;
     status: import("../../client/mutations/types").MutationStatus;
-    context: unknown;
+    context: TContext | undefined;
     submittedAt: number;
-    mutate: (mutationArgs: Args) => void;
+    mutate: (mutationArgs: TVariables) => void;
     cancel: () => void;
 };

package/dist/lib/queries/react/mutations/useMutationState.d.ts

@@ -1,7 +1,8 @@
 import { type MutationState, type MutationFilters } from "../../client/mutations/types";
 import { type Mutation } from "../../client/mutations/Mutation";
+import { type QueryClient } from "../../client/createClient";
 export interface MutationStateOptions<TResult, TData> {
     filters?: MutationFilters<TData>;
     select?: (mutation: Mutation<any>) => TResult;
 }
-export declare const useMutationState: <TData, TResult = MutationState<unknown, unknown, void, unknown>>({ filters, select }?: MutationStateOptions<TResult, TData>) => TResult[];
+export declare const useMutationState: <TData, TResult = MutationState<unknown, unknown, void, unknown>>({ filters, select }?: MutationStateOptions<TResult, TData>, queryClient?: QueryClient) => TResult[];