reactjrx 1.60.0 → 1.61.0

package/dist/index.cjs

@@ -481,21 +481,21 @@ function useMutation(options, queryClient) {
     },
     [finalQueryClient, key]
   );
-  const reset = react.useCallback(() => {
-    finalQueryClient.mutationClient.reset({
+  const cancel = react.useCallback(() => {
+    finalQueryClient.mutationClient.cancel({
       key: optionsRef.current.mutationKey ?? defaultKey.current
     });
   }, [finalQueryClient]);
   react.useEffect(() => {
     return () => {
       if (optionsRef.current.cancelOnUnMount) {
-        finalQueryClient.mutationClient.reset({
+        finalQueryClient.mutationClient.cancel({
           key: optionsRef.current.mutationKey ?? defaultKey.current
         });
       }
     };
   }, []);
-  return { mutate, reset, ...result };
+  return { mutate, cancel, ...result };
 }
 const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
 function shallowEqual(objA, objB) {
@@ -1473,7 +1473,9 @@ const mergeResults = (stream$) => stream$.pipe(
     (acc, current) => {
       return {
         ...acc,
-        ...current
+        ...current,
+        data: current.data ?? acc.data,
+        error: current.error ?? acc.error
       };
     },
     {
@@ -1486,25 +1488,99 @@ const mergeResults = (stream$) => stream$.pipe(
     ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
   )
 );
+const getDefaultMutationState = () => ({
+  context: {},
+  data: void 0,
+  error: null,
+  status: "idle",
+  submittedAt: 0,
+  variables: void 0
+});
+class Mutation {
+  constructor({
+    args,
+    ...options
+  }) {
+    __publicField(this, "stateSubject", new rxjs.BehaviorSubject(
+      getDefaultMutationState()
+    ));
+    /**
+     * @important
+     * proxy for rect-query, not really useful
+     */
+    __publicField(this, "state", this.stateSubject.getValue());
+    __publicField(this, "options");
+    __publicField(this, "mutation$");
+    this.options = options;
+    const mutationFn = options.mutationFn;
+    this.state.variables = args;
+    this.stateSubject.next(this.state);
+    const mutationFnObservable = typeof mutationFn === "function" ? rxjs.defer(() => rxjs.from(mutationFn(args))) : mutationFn;
+    const queryRunner$ = mutationFnObservable.pipe(
+      retryOnError(options),
+      rxjs.take(1),
+      rxjs.map((data) => ({ data, isError: false })),
+      rxjs.catchError((error) => {
+        console.error(error);
+        if (options.onError != null) {
+          options.onError(error, args);
+        }
+        return rxjs.of({ data: error, isError: true });
+      })
+    );
+    const loading$ = rxjs.of({
+      status: "pending"
+    });
+    this.mutation$ = rxjs.merge(
+      loading$,
+      queryRunner$.pipe(
+        rxjs.map(({ data, isError }) => {
+          if (!isError) {
+            if (options.onSuccess != null)
+              options.onSuccess(data, args);
+          }
+          return isError ? {
+            status: "error",
+            error: data,
+            data: void 0
+          } : {
+            status: "success",
+            error: null,
+            data
+          };
+        })
+      )
+    ).pipe(
+      mergeResults,
+      rxjs.tap((value) => {
+        this.state = { ...this.state, ...value };
+        this.stateSubject.next(this.state);
+      }),
+      options.__queryRunnerHook ?? rxjs.identity,
+      rxjs.share()
+    );
+  }
+}
 const createMutationRunner = ({
   __queryFinalizeHook,
   __queryInitHook,
   __queryTriggerHook
 }) => {
   const trigger$ = new rxjs.Subject();
-  const reset$ = new rxjs.Subject();
+  const cancel$ = new rxjs.Subject();
   let closed = false;
   const mapOperator$ = new rxjs.BehaviorSubject("merge");
-  const mutationsRunning$ = new rxjs.BehaviorSubject(0);
+  const mutationsSubject = new rxjs.BehaviorSubject([]);
   const destroy = () => {
     if (closed) {
       throw new Error("Trying to close an already closed mutation");
     }
     closed = true;
     mapOperator$.complete();
-    mutationsRunning$.complete();
+    mutationsSubject.complete();
     trigger$.complete();
-    reset$.complete();
+    cancel$.next();
+    cancel$.complete();
   };
   const stableMapOperator$ = mapOperator$.pipe(
     rxjs.filter(isDefined),
@@ -1514,29 +1590,35 @@ const createMutationRunner = ({
     __queryInitHook ?? rxjs.identity,
     rxjs.mergeMap((mapOperator) => {
       const switchOperator = mapOperator === "concat" ? rxjs.concatMap : mapOperator === "switch" ? rxjs.switchMap : rxjs.mergeMap;
+      let mutationsForCurrentMapOperatorSubject = [];
+      const removeMutation = (mutation) => {
+        mutationsForCurrentMapOperatorSubject = mutationsForCurrentMapOperatorSubject.filter(
+          (item) => item !== mutation
+        );
+        mutationsSubject.next(
+          mutationsSubject.getValue().filter((item) => item !== mutation)
+        );
+      };
       return trigger$.pipe(
         rxjs.takeUntil(stableMapOperator$.pipe(rxjs.skip(1))),
-        rxjs.tap(() => {
-          mutationsRunning$.next(mutationsRunning$.getValue() + 1);
+        rxjs.map(({ args, options }) => {
+          const mutation = new Mutation({
+            args,
+            ...options,
+            mapOperator
+          });
+          mutationsForCurrentMapOperatorSubject = [
+            ...mutationsForCurrentMapOperatorSubject,
+            mutation
+          ];
+          mutationsSubject.next([...mutationsSubject.getValue(), mutation]);
+          return mutation;
         }),
-        switchOperator(({ args, options }) => {
-          const mutationFn = options.mutationFn;
-          const mutationFnObservable = typeof mutationFn === "function" ? rxjs.defer(() => rxjs.from(mutationFn(args))) : mutationFn;
-          const queryRunner$ = mutationFnObservable.pipe(
-            retryOnError(options),
-            rxjs.take(1),
-            rxjs.map((data) => ({ data, isError: false })),
-            rxjs.catchError((error) => {
-              console.error(error);
-              if (options.onError != null) {
-                options.onError(error, args);
-              }
-              return rxjs.of({ data: error, isError: true });
-            }),
-            rxjs.share()
-          );
-          const queryIsOver$ = queryRunner$.pipe(
-            rxjs.map(({ data, isError }) => isError || data)
+        switchOperator((mutation) => {
+          if (!mutationsSubject.getValue().includes(mutation))
+            return rxjs.of({});
+          const queryIsOver$ = mutation.mutation$.pipe(
+            rxjs.map(({ data, error }) => error || data)
           );
           const isThisCurrentFunctionLastOneCalled = trigger$.pipe(
             rxjs.take(1),
@@ -1544,48 +1626,35 @@ const createMutationRunner = ({
             rxjs.startWith(true),
             rxjs.takeUntil(queryIsOver$)
           );
-          const loading$ = rxjs.of({
-            status: "pending"
-          });
-          return rxjs.merge(
-            loading$,
-            rxjs.combineLatest([
-              queryRunner$,
-              isThisCurrentFunctionLastOneCalled
-            ]).pipe(
-              rxjs.map(([{ data, isError }, isLastMutationCalled]) => {
-                if (!isError) {
-                  if (options.onSuccess != null)
-                    options.onSuccess(data, args);
-                }
-                if (isLastMutationCalled) {
-                  return isError ? {
-                    status: "error",
-                    error: data,
-                    data: void 0
-                  } : {
-                    status: "success",
-                    error: void 0,
-                    data
-                  };
-                }
+          const result$ = rxjs.combineLatest([
+            mutation.mutation$,
+            isThisCurrentFunctionLastOneCalled
+          ]).pipe(
+            rxjs.map(([result, isLastMutationCalled]) => {
+              if ((result.status === "success" || result.status === "error") && !isLastMutationCalled) {
                 return {};
-              }),
-              rxjs.takeUntil(reset$)
-            )
-          ).pipe(
-            options.__queryRunnerHook ?? rxjs.identity,
+              }
+              return result;
+            }),
+            rxjs.takeUntil(cancel$.pipe()),
+            mergeResults,
             rxjs.finalize(() => {
-              mutationsRunning$.next(mutationsRunning$.getValue() - 1);
+              removeMutation(mutation);
             })
           );
+          return result$;
         }),
-        __queryTriggerHook ?? rxjs.identity,
-        mergeResults
+        mergeResults,
+        __queryTriggerHook ?? rxjs.identity
       );
     }),
     __queryFinalizeHook ?? rxjs.identity
   );
+  cancel$.subscribe(() => {
+    if (mutationsSubject.getValue().length === 0)
+      return;
+    mutationsSubject.next([]);
+  });
   return {
     mutation$,
     trigger: ({
@@ -1595,12 +1664,29 @@ const createMutationRunner = ({
       mapOperator$.next(options.mapOperator);
       trigger$.next({ args, options });
     },
-    reset$,
+    cancel$,
     destroy,
-    mutationsRunning$,
+    mutationsSubject,
     getClosed: () => closed
   };
 };
+const createPredicateForFilters = ({
+  mutationKey,
+  status,
+  predicate
+} = {}) => {
+  const defaultPredicate = (mutation) => {
+    if (mutationKey !== void 0 && // @todo optimize
+    serializeKey(mutation.options.mutationKey) !== serializeKey(mutationKey)) {
+      return false;
+    }
+    if (status && mutation.stateSubject.getValue().status !== status)
+      return false;
+    return true;
+  };
+  const finalPredicate = predicate ?? defaultPredicate;
+  return finalPredicate;
+};
 class MutationClient {
   constructor() {
     /**
@@ -1620,11 +1706,15 @@ class MutationClient {
      */
     __publicField(this, "mutationResults$", new rxjs.BehaviorSubject(/* @__PURE__ */ new Map()));
     __publicField(this, "mutate$", new rxjs.Subject());
-    __publicField(this, "reset$", new rxjs.Subject());
+    __publicField(this, "cancel$", new rxjs.Subject());
     /**
      * Observable to track how many running mutations per runner
      */
     __publicField(this, "isMutatingSubject", new rxjs.BehaviorSubject([]));
+    /**
+     * List of all mutations running
+     */
+    __publicField(this, "mutationsSubject", new rxjs.BehaviorSubject([]));
     this.mutate$.pipe(
       rxjs.tap(({ options, args }) => {
         const { mutationKey } = options;
@@ -1649,9 +1739,10 @@ class MutationClient {
               resultForKeySubject == null ? void 0 : resultForKeySubject.next(result);
             }
           });
-          mutationForKey.mutationsRunning$.pipe(
+          mutationForKey.mutationsSubject.pipe(
+            rxjs.distinctUntilChanged(shallowEqual),
             rxjs.skip(1),
-            rxjs.filter((number) => number === 0)
+            rxjs.filter((items) => items.length === 0)
           ).subscribe(() => {
             mutationForKey == null ? void 0 : mutationForKey.destroy();
             const resultMap = this.mutationResults$.getValue();
@@ -1663,28 +1754,32 @@ class MutationClient {
         mutationForKey.trigger({ args, options });
       })
     ).subscribe();
-    this.reset$.pipe(
+    this.cancel$.pipe(
       rxjs.tap(({ key }) => {
         var _a;
         const serializedKey = serializeKey(key);
-        (_a = this.mutationRunnersByKey$.getValue().get(serializedKey)) == null ? void 0 : _a.reset$.next();
+        (_a = this.mutationRunnersByKey$.getValue().get(serializedKey)) == null ? void 0 : _a.cancel$.next();
       })
     ).subscribe();
     this.mutationRunnersByKey$.pipe(
       rxjs.switchMap((mapItem) => {
-        const mutationRunners = Array.from(mapItem.entries()).map(
-          ([, value]) => value.mutationsRunning$.pipe(
-            rxjs.map((number) => [value.mutationKey, number])
+        const mutationRunners = Array.from(mapItem.values());
+        const mutations$ = rxjs.combineLatest(
+          mutationRunners.map(
+            (runner) => runner.mutationsSubject.pipe(
+              rxjs.map((mutations) => mutations.map((mutation) => mutation))
+            )
           )
         );
-        const mutationRunnersMutationsRunning$ = rxjs.combineLatest([
-          // when map is empty we still need to push 0
-          rxjs.of([[], 0]),
-          ...mutationRunners
-        ]);
-        return mutationRunnersMutationsRunning$;
-      })
-    ).subscribe(this.isMutatingSubject);
+        return mutations$.pipe(
+          rxjs.map(
+            (mutationsByKeys) => mutationsByKeys.reduce((acc, value) => [...acc, ...value], [])
+          )
+        );
+      }),
+      rxjs.startWith([]),
+      rxjs.distinctUntilChanged(shallowEqual)
+    ).subscribe(this.mutationsSubject);
   }
   /**
    * @helper
@@ -1708,22 +1803,48 @@ class MutationClient {
   getMutationRunnersByKey(key) {
     return this.mutationRunnersByKey$.getValue().get(key);
   }
-  useIsMutating({ mutationKey, predicate } = {}) {
-    const defaultPredicate = ({ options }) => mutationKey ? (
-      // @todo optimize
-      serializeKey(options.mutationKey) === serializeKey(mutationKey)
-    ) : true;
-    const finalPredicate = predicate ?? defaultPredicate;
-    const reduceByNumber = (entries) => entries.reduce((acc, [mutationKey2, value]) => {
-      return finalPredicate({ options: { mutationKey: mutationKey2 } }) ? value + acc : acc;
+  useIsMutating(filters = {}) {
+    const predicate = createPredicateForFilters(filters);
+    const reduceByNumber = (entries) => entries.reduce((acc, mutation) => {
+      return predicate(mutation) && mutation.stateSubject.getValue().status === "pending" ? 1 + acc : acc;
     }, 0);
-    const lastValue = reduceByNumber(this.isMutatingSubject.getValue());
-    const value$ = this.isMutatingSubject.pipe(
-      rxjs.map((mutationRunningByKeys) => reduceByNumber(mutationRunningByKeys)),
+    const lastValue = reduceByNumber(this.mutationsSubject.getValue());
+    const value$ = this.mutationsSubject.pipe(
+      rxjs.switchMap((mutations) => {
+        const mutationsOnStateUpdate = mutations.map(
+          (mutation) => mutation.stateSubject.pipe(rxjs.map(() => mutation))
+        );
+        return mutationsOnStateUpdate.length === 0 ? rxjs.of([]) : rxjs.combineLatest(mutationsOnStateUpdate);
+      }),
+      rxjs.map(reduceByNumber),
       rxjs.distinctUntilChanged()
     );
     return { value$, lastValue };
   }
+  mutationState({
+    filters,
+    select
+  } = {}) {
+    const predicate = createPredicateForFilters(filters);
+    const finalSelect = select ?? ((mutation) => mutation.stateSubject.getValue());
+    const lastValue = this.mutationsSubject.getValue().reduce((acc, mutation) => {
+      const result = [...acc, mutation];
+      return result;
+    }, []).filter(predicate).map((mutation) => finalSelect(mutation));
+    const value$ = this.mutationsSubject.pipe(
+      rxjs.switchMap((mutations) => {
+        const mutationsOnStateUpdate = mutations.map(
+          (mutation) => mutation.stateSubject.pipe(
+            rxjs.filter(() => predicate(mutation)),
+            rxjs.map(() => finalSelect(mutation))
+          )
+        );
+        return mutationsOnStateUpdate.length === 0 ? rxjs.of([]) : rxjs.combineLatest(mutationsOnStateUpdate);
+      }),
+      rxjs.distinctUntilChanged(shallowEqual)
+    );
+    return { value$, lastValue };
+  }
   observe({ key }) {
     var _a;
     const currentResultValue = (_a = this.mutationResults$.getValue().get(key)) == null ? void 0 : _a.getValue();
@@ -1762,18 +1883,19 @@ class MutationClient {
     this.mutate$.next(params);
   }
   /**
-   * This will reset any current mutation runnings.
+   * This will cancel any current mutation runnings.
    * No discrimination process
    */
-  reset(params) {
-    this.reset$.next(params);
+  cancel(params) {
+    this.cancel$.next(params);
   }
   destroy() {
-    this.reset$.complete();
+    this.cancel$.complete();
     this.mutate$.complete();
     this.mutationResults$.complete();
     this.mutationRunnersByKey$.complete();
     this.isMutatingSubject.complete();
+    this.mutationsSubject.complete();
   }
 }
 const createClient = () => {

package/dist/index.js

@@ -479,21 +479,21 @@ function useMutation(options, queryClient) {
     },
     [finalQueryClient, key]
   );
-  const reset = useCallback(() => {
-    finalQueryClient.mutationClient.reset({
+  const cancel = useCallback(() => {
+    finalQueryClient.mutationClient.cancel({
       key: optionsRef.current.mutationKey ?? defaultKey.current
     });
   }, [finalQueryClient]);
   useEffect(() => {
     return () => {
       if (optionsRef.current.cancelOnUnMount) {
-        finalQueryClient.mutationClient.reset({
+        finalQueryClient.mutationClient.cancel({
           key: optionsRef.current.mutationKey ?? defaultKey.current
         });
       }
     };
   }, []);
-  return { mutate, reset, ...result };
+  return { mutate, cancel, ...result };
 }
 const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
 function shallowEqual(objA, objB) {
@@ -1471,7 +1471,9 @@ const mergeResults = (stream$) => stream$.pipe(
     (acc, current) => {
       return {
         ...acc,
-        ...current
+        ...current,
+        data: current.data ?? acc.data,
+        error: current.error ?? acc.error
       };
     },
     {
@@ -1484,25 +1486,99 @@ const mergeResults = (stream$) => stream$.pipe(
     ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
   )
 );
+const getDefaultMutationState = () => ({
+  context: {},
+  data: void 0,
+  error: null,
+  status: "idle",
+  submittedAt: 0,
+  variables: void 0
+});
+class Mutation {
+  constructor({
+    args,
+    ...options
+  }) {
+    __publicField(this, "stateSubject", new BehaviorSubject(
+      getDefaultMutationState()
+    ));
+    /**
+     * @important
+     * proxy for rect-query, not really useful
+     */
+    __publicField(this, "state", this.stateSubject.getValue());
+    __publicField(this, "options");
+    __publicField(this, "mutation$");
+    this.options = options;
+    const mutationFn = options.mutationFn;
+    this.state.variables = args;
+    this.stateSubject.next(this.state);
+    const mutationFnObservable = typeof mutationFn === "function" ? defer(() => from(mutationFn(args))) : mutationFn;
+    const queryRunner$ = mutationFnObservable.pipe(
+      retryOnError(options),
+      take(1),
+      map((data) => ({ data, isError: false })),
+      catchError((error) => {
+        console.error(error);
+        if (options.onError != null) {
+          options.onError(error, args);
+        }
+        return of({ data: error, isError: true });
+      })
+    );
+    const loading$ = of({
+      status: "pending"
+    });
+    this.mutation$ = merge(
+      loading$,
+      queryRunner$.pipe(
+        map(({ data, isError }) => {
+          if (!isError) {
+            if (options.onSuccess != null)
+              options.onSuccess(data, args);
+          }
+          return isError ? {
+            status: "error",
+            error: data,
+            data: void 0
+          } : {
+            status: "success",
+            error: null,
+            data
+          };
+        })
+      )
+    ).pipe(
+      mergeResults,
+      tap((value) => {
+        this.state = { ...this.state, ...value };
+        this.stateSubject.next(this.state);
+      }),
+      options.__queryRunnerHook ?? identity,
+      share()
+    );
+  }
+}
 const createMutationRunner = ({
   __queryFinalizeHook,
   __queryInitHook,
   __queryTriggerHook
 }) => {
   const trigger$ = new Subject();
-  const reset$ = new Subject();
+  const cancel$ = new Subject();
   let closed = false;
   const mapOperator$ = new BehaviorSubject("merge");
-  const mutationsRunning$ = new BehaviorSubject(0);
+  const mutationsSubject = new BehaviorSubject([]);
   const destroy = () => {
     if (closed) {
       throw new Error("Trying to close an already closed mutation");
     }
     closed = true;
     mapOperator$.complete();
-    mutationsRunning$.complete();
+    mutationsSubject.complete();
     trigger$.complete();
-    reset$.complete();
+    cancel$.next();
+    cancel$.complete();
   };
   const stableMapOperator$ = mapOperator$.pipe(
     filter(isDefined),
@@ -1512,29 +1588,35 @@ const createMutationRunner = ({
     __queryInitHook ?? identity,
     mergeMap((mapOperator) => {
       const switchOperator = mapOperator === "concat" ? concatMap$1 : mapOperator === "switch" ? switchMap : mergeMap;
+      let mutationsForCurrentMapOperatorSubject = [];
+      const removeMutation = (mutation) => {
+        mutationsForCurrentMapOperatorSubject = mutationsForCurrentMapOperatorSubject.filter(
+          (item) => item !== mutation
+        );
+        mutationsSubject.next(
+          mutationsSubject.getValue().filter((item) => item !== mutation)
+        );
+      };
       return trigger$.pipe(
         takeUntil(stableMapOperator$.pipe(skip(1))),
-        tap(() => {
-          mutationsRunning$.next(mutationsRunning$.getValue() + 1);
+        map(({ args, options }) => {
+          const mutation = new Mutation({
+            args,
+            ...options,
+            mapOperator
+          });
+          mutationsForCurrentMapOperatorSubject = [
+            ...mutationsForCurrentMapOperatorSubject,
+            mutation
+          ];
+          mutationsSubject.next([...mutationsSubject.getValue(), mutation]);
+          return mutation;
         }),
-        switchOperator(({ args, options }) => {
-          const mutationFn = options.mutationFn;
-          const mutationFnObservable = typeof mutationFn === "function" ? defer(() => from(mutationFn(args))) : mutationFn;
-          const queryRunner$ = mutationFnObservable.pipe(
-            retryOnError(options),
-            take(1),
-            map((data) => ({ data, isError: false })),
-            catchError((error) => {
-              console.error(error);
-              if (options.onError != null) {
-                options.onError(error, args);
-              }
-              return of({ data: error, isError: true });
-            }),
-            share()
-          );
-          const queryIsOver$ = queryRunner$.pipe(
-            map(({ data, isError }) => isError || data)
+        switchOperator((mutation) => {
+          if (!mutationsSubject.getValue().includes(mutation))
+            return of({});
+          const queryIsOver$ = mutation.mutation$.pipe(
+            map(({ data, error }) => error || data)
           );
           const isThisCurrentFunctionLastOneCalled = trigger$.pipe(
             take(1),
@@ -1542,48 +1624,35 @@ const createMutationRunner = ({
             startWith(true),
             takeUntil(queryIsOver$)
           );
-          const loading$ = of({
-            status: "pending"
-          });
-          return merge(
-            loading$,
-            combineLatest([
-              queryRunner$,
-              isThisCurrentFunctionLastOneCalled
-            ]).pipe(
-              map(([{ data, isError }, isLastMutationCalled]) => {
-                if (!isError) {
-                  if (options.onSuccess != null)
-                    options.onSuccess(data, args);
-                }
-                if (isLastMutationCalled) {
-                  return isError ? {
-                    status: "error",
-                    error: data,
-                    data: void 0
-                  } : {
-                    status: "success",
-                    error: void 0,
-                    data
-                  };
-                }
+          const result$ = combineLatest([
+            mutation.mutation$,
+            isThisCurrentFunctionLastOneCalled
+          ]).pipe(
+            map(([result, isLastMutationCalled]) => {
+              if ((result.status === "success" || result.status === "error") && !isLastMutationCalled) {
                 return {};
-              }),
-              takeUntil(reset$)
-            )
-          ).pipe(
-            options.__queryRunnerHook ?? identity,
+              }
+              return result;
+            }),
+            takeUntil(cancel$.pipe()),
+            mergeResults,
             finalize(() => {
-              mutationsRunning$.next(mutationsRunning$.getValue() - 1);
+              removeMutation(mutation);
             })
           );
+          return result$;
         }),
-        __queryTriggerHook ?? identity,
-        mergeResults
+        mergeResults,
+        __queryTriggerHook ?? identity
       );
     }),
     __queryFinalizeHook ?? identity
   );
+  cancel$.subscribe(() => {
+    if (mutationsSubject.getValue().length === 0)
+      return;
+    mutationsSubject.next([]);
+  });
   return {
     mutation$,
     trigger: ({
@@ -1593,12 +1662,29 @@ const createMutationRunner = ({
       mapOperator$.next(options.mapOperator);
       trigger$.next({ args, options });
     },
-    reset$,
+    cancel$,
     destroy,
-    mutationsRunning$,
+    mutationsSubject,
     getClosed: () => closed
   };
 };
+const createPredicateForFilters = ({
+  mutationKey,
+  status,
+  predicate
+} = {}) => {
+  const defaultPredicate = (mutation) => {
+    if (mutationKey !== void 0 && // @todo optimize
+    serializeKey(mutation.options.mutationKey) !== serializeKey(mutationKey)) {
+      return false;
+    }
+    if (status && mutation.stateSubject.getValue().status !== status)
+      return false;
+    return true;
+  };
+  const finalPredicate = predicate ?? defaultPredicate;
+  return finalPredicate;
+};
 class MutationClient {
   constructor() {
     /**
@@ -1618,11 +1704,15 @@ class MutationClient {
      */
     __publicField(this, "mutationResults$", new BehaviorSubject(/* @__PURE__ */ new Map()));
     __publicField(this, "mutate$", new Subject());
-    __publicField(this, "reset$", new Subject());
+    __publicField(this, "cancel$", new Subject());
     /**
      * Observable to track how many running mutations per runner
      */
     __publicField(this, "isMutatingSubject", new BehaviorSubject([]));
+    /**
+     * List of all mutations running
+     */
+    __publicField(this, "mutationsSubject", new BehaviorSubject([]));
     this.mutate$.pipe(
       tap(({ options, args }) => {
         const { mutationKey } = options;
@@ -1647,9 +1737,10 @@ class MutationClient {
               resultForKeySubject == null ? void 0 : resultForKeySubject.next(result);
             }
           });
-          mutationForKey.mutationsRunning$.pipe(
+          mutationForKey.mutationsSubject.pipe(
+            distinctUntilChanged(shallowEqual),
             skip(1),
-            filter((number) => number === 0)
+            filter((items) => items.length === 0)
           ).subscribe(() => {
             mutationForKey == null ? void 0 : mutationForKey.destroy();
             const resultMap = this.mutationResults$.getValue();
@@ -1661,28 +1752,32 @@ class MutationClient {
         mutationForKey.trigger({ args, options });
       })
     ).subscribe();
-    this.reset$.pipe(
+    this.cancel$.pipe(
       tap(({ key }) => {
         var _a;
         const serializedKey = serializeKey(key);
-        (_a = this.mutationRunnersByKey$.getValue().get(serializedKey)) == null ? void 0 : _a.reset$.next();
+        (_a = this.mutationRunnersByKey$.getValue().get(serializedKey)) == null ? void 0 : _a.cancel$.next();
       })
     ).subscribe();
     this.mutationRunnersByKey$.pipe(
       switchMap((mapItem) => {
-        const mutationRunners = Array.from(mapItem.entries()).map(
-          ([, value]) => value.mutationsRunning$.pipe(
-            map((number) => [value.mutationKey, number])
+        const mutationRunners = Array.from(mapItem.values());
+        const mutations$ = combineLatest(
+          mutationRunners.map(
+            (runner) => runner.mutationsSubject.pipe(
+              map((mutations) => mutations.map((mutation) => mutation))
+            )
           )
         );
-        const mutationRunnersMutationsRunning$ = combineLatest([
-          // when map is empty we still need to push 0
-          of([[], 0]),
-          ...mutationRunners
-        ]);
-        return mutationRunnersMutationsRunning$;
-      })
-    ).subscribe(this.isMutatingSubject);
+        return mutations$.pipe(
+          map(
+            (mutationsByKeys) => mutationsByKeys.reduce((acc, value) => [...acc, ...value], [])
+          )
+        );
+      }),
+      startWith([]),
+      distinctUntilChanged(shallowEqual)
+    ).subscribe(this.mutationsSubject);
   }
   /**
    * @helper
@@ -1706,22 +1801,48 @@ class MutationClient {
   getMutationRunnersByKey(key) {
     return this.mutationRunnersByKey$.getValue().get(key);
   }
-  useIsMutating({ mutationKey, predicate } = {}) {
-    const defaultPredicate = ({ options }) => mutationKey ? (
-      // @todo optimize
-      serializeKey(options.mutationKey) === serializeKey(mutationKey)
-    ) : true;
-    const finalPredicate = predicate ?? defaultPredicate;
-    const reduceByNumber = (entries) => entries.reduce((acc, [mutationKey2, value]) => {
-      return finalPredicate({ options: { mutationKey: mutationKey2 } }) ? value + acc : acc;
+  useIsMutating(filters = {}) {
+    const predicate = createPredicateForFilters(filters);
+    const reduceByNumber = (entries) => entries.reduce((acc, mutation) => {
+      return predicate(mutation) && mutation.stateSubject.getValue().status === "pending" ? 1 + acc : acc;
     }, 0);
-    const lastValue = reduceByNumber(this.isMutatingSubject.getValue());
-    const value$ = this.isMutatingSubject.pipe(
-      map((mutationRunningByKeys) => reduceByNumber(mutationRunningByKeys)),
+    const lastValue = reduceByNumber(this.mutationsSubject.getValue());
+    const value$ = this.mutationsSubject.pipe(
+      switchMap((mutations) => {
+        const mutationsOnStateUpdate = mutations.map(
+          (mutation) => mutation.stateSubject.pipe(map(() => mutation))
+        );
+        return mutationsOnStateUpdate.length === 0 ? of([]) : combineLatest(mutationsOnStateUpdate);
+      }),
+      map(reduceByNumber),
       distinctUntilChanged()
     );
     return { value$, lastValue };
   }
+  mutationState({
+    filters,
+    select
+  } = {}) {
+    const predicate = createPredicateForFilters(filters);
+    const finalSelect = select ?? ((mutation) => mutation.stateSubject.getValue());
+    const lastValue = this.mutationsSubject.getValue().reduce((acc, mutation) => {
+      const result = [...acc, mutation];
+      return result;
+    }, []).filter(predicate).map((mutation) => finalSelect(mutation));
+    const value$ = this.mutationsSubject.pipe(
+      switchMap((mutations) => {
+        const mutationsOnStateUpdate = mutations.map(
+          (mutation) => mutation.stateSubject.pipe(
+            filter(() => predicate(mutation)),
+            map(() => finalSelect(mutation))
+          )
+        );
+        return mutationsOnStateUpdate.length === 0 ? of([]) : combineLatest(mutationsOnStateUpdate);
+      }),
+      distinctUntilChanged(shallowEqual)
+    );
+    return { value$, lastValue };
+  }
   observe({ key }) {
     var _a;
     const currentResultValue = (_a = this.mutationResults$.getValue().get(key)) == null ? void 0 : _a.getValue();
@@ -1760,18 +1881,19 @@ class MutationClient {
     this.mutate$.next(params);
   }
   /**
-   * This will reset any current mutation runnings.
+   * This will cancel any current mutation runnings.
    * No discrimination process
    */
-  reset(params) {
-    this.reset$.next(params);
+  cancel(params) {
+    this.cancel$.next(params);
   }
   destroy() {
-    this.reset$.complete();
+    this.cancel$.complete();
     this.mutate$.complete();
     this.mutationResults$.complete();
     this.mutationRunnersByKey$.complete();
     this.isMutatingSubject.complete();
+    this.mutationsSubject.complete();
   }
 }
 const createClient = () => {

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

@@ -0,0 +1,15 @@
+import { BehaviorSubject, type Observable } from "rxjs";
+import { type MutationState, type MutationOptions, type MutationResult } from "./types";
+export declare class Mutation<Data> {
+    stateSubject: BehaviorSubject<MutationState<Data, unknown, void, unknown>>;
+    /**
+     * @important
+     * proxy for rect-query, not really useful
+     */
+    state: MutationState<Data>;
+    options: MutationOptions<Data, any>;
+    mutation$: Observable<MutationResult<Data>>;
+    constructor({ args, ...options }: {
+        args: any;
+    } & MutationOptions<Data, any>);
+}

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

@@ -1,6 +1,7 @@
 import { Subject, BehaviorSubject, type Observable } from "rxjs";
-import { type MutationResult, type MutationOptions, type MutationObservedResult, type MutationFilters, type MutationKey } from "./types";
+import { type MutationResult, type MutationOptions, type MutationObservedResult, type MutationFilters, type MutationKey, type MutationState } from "./types";
 import { type QueryKey } from "../keys/types";
+import { type Mutation } from "./Mutation";
 export declare class MutationClient {
     /**
      * Contain all active mutation for a given key.
@@ -15,9 +16,9 @@ export declare class MutationClient {
             args: unknown;
             options: MutationOptions<unknown, unknown>;
         }) => void;
-        reset$: Subject<void>;
+        cancel$: Subject<void>;
         destroy: () => void;
-        mutationsRunning$: BehaviorSubject<number>;
+        mutationsSubject: BehaviorSubject<Mutation<any>[]>;
         getClosed: () => boolean;
     } & {
         mutationKey: MutationKey;
@@ -34,13 +35,17 @@ export declare class MutationClient {
         options: MutationOptions<any, any>;
         args: any;
     }>;
-    reset$: Subject<{
+    cancel$: Subject<{
         key: QueryKey;
     }>;
     /**
      * Observable to track how many running mutations per runner
      */
     isMutatingSubject: BehaviorSubject<(readonly [MutationKey, number])[]>;
+    /**
+     * List of all mutations running
+     */
+    mutationsSubject: BehaviorSubject<Mutation<any>[]>;
     constructor();
     /**
      * @helper
@@ -59,17 +64,24 @@ export declare class MutationClient {
             args: unknown;
             options: MutationOptions<unknown, unknown>;
         }) => void;
-        reset$: Subject<void>;
+        cancel$: Subject<void>;
         destroy: () => void;
-        mutationsRunning$: BehaviorSubject<number>;
+        mutationsSubject: BehaviorSubject<Mutation<any>[]>;
         getClosed: () => boolean;
     } & {
         mutationKey: MutationKey;
     }) | undefined;
-    useIsMutating({ mutationKey, predicate }?: MutationFilters): {
+    useIsMutating<TData>(filters?: MutationFilters<TData>): {
         value$: Observable<number>;
         lastValue: number;
     };
+    mutationState<TData, Selected = MutationState<TData>>({ filters, select }?: {
+        filters?: MutationFilters<TData>;
+        select?: (mutation: Mutation<TData>) => Selected;
+    }): {
+        value$: Observable<Selected[]>;
+        lastValue: Selected[];
+    };
     observe<Result>({ key }: {
         key: string;
     }): {
@@ -81,10 +93,10 @@ export declare class MutationClient {
         args: MutationArgs;
     }): void;
     /**
-     * This will reset any current mutation runnings.
+     * This will cancel any current mutation runnings.
      * No discrimination process
      */
-    reset(params: {
+    cancel(params: {
         key: QueryKey;
     }): void;
     destroy(): void;

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

@@ -1,13 +1,15 @@
 import { BehaviorSubject, Subject } from "rxjs";
-import { type MutationOptions, type MutationResult } from "./types";
+import { type MutationOptions } from "./types";
+import { Mutation } from "./Mutation";
+export type MutationRunner = ReturnType<typeof createMutationRunner>;
 export declare const createMutationRunner: <T, MutationArg>({ __queryFinalizeHook, __queryInitHook, __queryTriggerHook }: Pick<MutationOptions<any, any>, "__queryInitHook" | "__queryTriggerHook" | "__queryFinalizeHook">) => {
-    mutation$: import("rxjs").Observable<MutationResult<T>>;
+    mutation$: import("rxjs").Observable<import("./types").MutationResult<unknown>>;
     trigger: ({ args, options }: {
         args: MutationArg;
         options: MutationOptions<T, MutationArg>;
     }) => void;
-    reset$: Subject<void>;
+    cancel$: Subject<void>;
     destroy: () => void;
-    mutationsRunning$: BehaviorSubject<number>;
+    mutationsSubject: BehaviorSubject<Mutation<any>[]>;
     getClosed: () => boolean;
 };

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

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

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

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

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

@@ -1,5 +1,6 @@
 import { type MonoTypeOperatorFunction, type Observable } from "rxjs";
 import { type Query, type QueryResult } from "../types";
+import { type Mutation } from "./Mutation";
 /**
  * The default value `merge` is suitable for most use case.
  * You should not have to worry too much about it and only consider changing
@@ -25,19 +26,14 @@ 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 {
+export interface MutationFilters<TData> {
     /**
      * Match mutation key exactly
      */
-    exact?: boolean;
     /**
      * Include mutations matching this predicate function
      */
-    predicate?: (mutation: {
-        options: {
-            mutationKey: MutationKey;
-        };
-    }) => boolean;
+    predicate?: (mutation: Mutation<TData>) => boolean;
     /**
      * Include mutations matching this mutation key
      */
@@ -59,7 +55,7 @@ export interface MutationObservedResult<R> extends MutationResult<R> {
     isPending: boolean;
     isPaused: boolean;
 }
-export type MutationFn<T, MutationArg> = Observable<T> | ((arg: MutationArg) => Promise<T>) | ((arg: MutationArg) => Observable<T>);
+export type MutationFn<Data, MutationArg> = Observable<Data> | ((arg: MutationArg) => Promise<Data>) | ((arg: MutationArg) => Observable<Data>);
 export interface MutationOptions<Result, MutationArg> {
     enabled?: boolean;
     retry?: false | number | ((attempt: number, error: unknown) => boolean);
@@ -90,3 +86,11 @@ export interface MutationOptions<Result, MutationArg> {
     __queryTriggerHook?: MonoTypeOperatorFunction<Partial<Result>>;
     __queryFinalizeHook?: MonoTypeOperatorFunction<Partial<Result>>;
 }
+export interface MutationState<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> {
+    context: TContext | undefined;
+    data: TData | undefined;
+    error: TError;
+    status: MutationStatus;
+    variables: TVariables | undefined;
+    submittedAt: number;
+}

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

@@ -9,6 +9,11 @@ export interface QueryResult<T> {
     status: "loading" | "error" | "success";
     error: unknown;
 }
+export interface Register {
+}
+export type DefaultError = Register extends {
+    defaultError: infer TError;
+} ? TError : Error;
 export interface Query {
 }
 export interface QueryCommand<T> {

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

@@ -0,0 +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;

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

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

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

@@ -14,5 +14,5 @@ export declare function useMutation<Args = void, R = undefined>(options: AsyncQu
     status: import("../../client/mutations/types").MutationStatus;
     error: unknown;
     mutate: (mutationArgs: Args) => void;
-    reset: () => void;
+    cancel: () => void;
 };

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

@@ -1,3 +1,7 @@
-import { type MutationFilters } from "../../client/mutations/types";
-import { type QueryClient } from "../../client/createClient";
-export declare const useIsMutating: ({ mutationKey, predicate }?: MutationFilters, queryClient?: QueryClient) => number;
+import { type MutationState, type MutationFilters } from "../../client/mutations/types";
+import { type Mutation } from "../../client/mutations/Mutation";
+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[];

package/dist/tests/utils.d.ts

@@ -19,3 +19,4 @@ export declare function renderWithClient(client: QueryClient, ui: React.ReactEle
  * @see https://github.com/TanStack/query/blob/main/packages/react-query/src/__tests__/utils.tsx
  */
 export declare function createQueryClient(): QueryClient;
+export declare const doNotExecute: (_func: () => void) => boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reactjrx",
   "private": false,
-  "version": "1.60.0",
+  "version": "1.61.0",
   "type": "module",
   "files": [
     "dist"