reactjrx 1.61.0 → 1.62.0

package/dist/index.cjs

@@ -465,7 +465,9 @@ function useMutation(options, queryClient) {
   const defaultKey = useConstant(() => [nanoid()]);
   const key = serializeKey(options.mutationKey ?? defaultKey.current);
   const observedMutation = react.useMemo(
-    () => finalQueryClient.mutationClient.observe({ key }),
+    () => finalQueryClient.mutationClient.mutationResultObserver.observe({
+      key
+    }),
     [key]
   );
   const result = useObserve(observedMutation.result$) ?? observedMutation.lastValue;
@@ -1468,47 +1470,38 @@ const dispatchExternalRefetchToAllQueries = ({
   }),
   rxjs.filter((trigger2) => trigger2.type !== "refetch")
 );
-const mergeResults = (stream$) => stream$.pipe(
-  rxjs.scan(
-    (acc, current) => {
-      return {
-        ...acc,
-        ...current,
-        data: current.data ?? acc.data,
-        error: current.error ?? acc.error
-      };
-    },
-    {
-      data: void 0,
-      error: void 0,
-      status: "pending"
-    }
-  ),
-  rxjs.distinctUntilChanged(
-    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
-  )
-);
 const getDefaultMutationState = () => ({
-  context: {},
+  context: void 0,
   data: void 0,
   error: null,
   status: "idle",
   submittedAt: 0,
   variables: void 0
 });
+const mergeResults = (stream$) => stream$.pipe(
+  rxjs.scan((acc, current) => {
+    return {
+      ...acc,
+      ...current,
+      data: current.data ?? acc.data,
+      error: current.error ?? acc.error
+    };
+  }, getDefaultMutationState()),
+  rxjs.distinctUntilChanged(
+    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
+  )
+);
 class Mutation {
   constructor({
     args,
     ...options
   }) {
-    __publicField(this, "stateSubject", new rxjs.BehaviorSubject(
-      getDefaultMutationState()
-    ));
+    __publicField(this, "stateSubject", new rxjs.ReplaySubject(1));
     /**
      * @important
-     * proxy for rect-query, not really useful
+     * convenience over usage of stateSubject for sync access
      */
-    __publicField(this, "state", this.stateSubject.getValue());
+    __publicField(this, "state", getDefaultMutationState());
     __publicField(this, "options");
     __publicField(this, "mutation$");
     this.options = options;
@@ -1528,11 +1521,13 @@ class Mutation {
         return rxjs.of({ data: error, isError: true });
       })
     );
-    const loading$ = rxjs.of({
-      status: "pending"
+    const initState$ = rxjs.of({
+      ...this.state,
+      status: "pending",
+      submittedAt: (/* @__PURE__ */ new Date()).getTime()
     });
     this.mutation$ = rxjs.merge(
-      loading$,
+      initState$,
       queryRunner$.pipe(
         rxjs.map(({ data, isError }) => {
           if (!isError) {
@@ -1648,7 +1643,8 @@ const createMutationRunner = ({
         __queryTriggerHook ?? rxjs.identity
       );
     }),
-    __queryFinalizeHook ?? rxjs.identity
+    __queryFinalizeHook ?? rxjs.identity,
+    rxjs.shareReplay(1)
   );
   cancel$.subscribe(() => {
     if (mutationsSubject.getValue().length === 0)
@@ -1680,31 +1676,109 @@ const createPredicateForFilters = ({
     serializeKey(mutation.options.mutationKey) !== serializeKey(mutationKey)) {
       return false;
     }
-    if (status && mutation.stateSubject.getValue().status !== status)
+    if (status && mutation.state.status !== status)
       return false;
     return true;
   };
   const finalPredicate = predicate ?? defaultPredicate;
   return finalPredicate;
 };
-class MutationClient {
-  constructor() {
+class MutationResultObserver {
+  constructor(mutationRunnersByKey$) {
     /**
-     * Contain all active mutation for a given key.
-     * A mutation ca have several triggers running (it is not necessarily one function running)
+     * Mutation result subject. It can be used whether there is a mutation
+     * running or not and can be directly observed.
      *
      * @important
      * - automatically cleaned as soon as the last mutation is done for a given key
      */
-    __publicField(this, "mutationRunnersByKey$", new rxjs.BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField(this, "mutationResults$", new rxjs.BehaviorSubject(/* @__PURE__ */ new Map()));
+    mutationRunnersByKey$.pipe(
+      rxjs.switchMap((mapItem) => {
+        const runners = Array.from(mapItem.values()).map((runner) => {
+          const serializedMutationKey = serializeKey(runner.mutationKey);
+          return runner.mutation$.pipe(
+            rxjs.tap((result) => {
+              this.updateResultForKey({
+                serializedMutationKey,
+                result
+              });
+            }),
+            rxjs.finalize(() => {
+              this.deleteResultForKey({ serializedMutationKey });
+            })
+          );
+        });
+        return rxjs.merge(...runners);
+      })
+    ).subscribe();
+  }
+  getDefaultResultValue() {
+    return {
+      ...getDefaultMutationState(),
+      isSuccess: false,
+      isPending: false,
+      isIdle: true,
+      isError: false
+    };
+  }
+  deleteResultForKey({
+    serializedMutationKey
+  }) {
+    const resultMap = this.mutationResults$.getValue();
+    resultMap.delete(serializedMutationKey);
+    this.mutationResults$.next(resultMap);
+  }
+  updateResultForKey({
+    serializedMutationKey,
+    result
+  }) {
+    const resultForKeySubject = this.mutationResults$.getValue().get(serializedMutationKey);
+    const valueForResult = {
+      ...this.getDefaultResultValue(),
+      ...result,
+      isSuccess: result.status === "success",
+      isPending: result.status === "pending",
+      isIdle: result.status === "idle",
+      isError: result.status === "error"
+    };
+    if (!resultForKeySubject) {
+      const resultMap = this.mutationResults$.getValue();
+      resultMap.set(
+        serializedMutationKey,
+        new rxjs.BehaviorSubject(valueForResult)
+      );
+      this.mutationResults$.next(resultMap);
+    } else {
+      resultForKeySubject == null ? void 0 : resultForKeySubject.next(valueForResult);
+    }
+  }
+  observe({ key }) {
+    var _a;
+    const currentResultValue = (_a = this.mutationResults$.getValue().get(key)) == null ? void 0 : _a.getValue();
+    const lastValue = currentResultValue ?? this.getDefaultResultValue();
+    const result$ = this.mutationResults$.pipe(
+      rxjs.switchMap((resultMap) => {
+        const subject = resultMap.get(key);
+        return subject ?? rxjs.EMPTY;
+      })
+    ).pipe(rxjs.filter(isDefined));
+    return { result$, lastValue };
+  }
+  destroy() {
+    this.mutationResults$.complete();
+  }
+}
+class MutationClient {
+  constructor() {
     /**
-     * Mutation result subject. It can be used whether there is a mutation
-     * running or not and can be directly observed.
+     * 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
      */
-    __publicField(this, "mutationResults$", new rxjs.BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField(this, "mutationRunnersByKey$", new rxjs.BehaviorSubject(/* @__PURE__ */ new Map()));
     __publicField(this, "mutate$", new rxjs.Subject());
     __publicField(this, "cancel$", new rxjs.Subject());
     /**
@@ -1715,6 +1789,9 @@ class MutationClient {
      * List of all mutations running
      */
     __publicField(this, "mutationsSubject", new rxjs.BehaviorSubject([]));
+    __publicField(this, "mutationResultObserver", new MutationResultObserver(
+      this.mutationRunnersByKey$
+    ));
     this.mutate$.pipe(
       rxjs.tap(({ options, args }) => {
         const { mutationKey } = options;
@@ -1728,26 +1805,13 @@ class MutationClient {
             mutationKey
           };
           this.setMutationRunnersByKey(serializedMutationKey, mutationForKey);
-          mutationForKey.mutation$.subscribe((result) => {
-            let resultForKeySubject = this.mutationResults$.getValue().get(serializedMutationKey);
-            if (!resultForKeySubject) {
-              resultForKeySubject = new rxjs.BehaviorSubject(result);
-              const resultMap = this.mutationResults$.getValue();
-              resultMap.set(serializedMutationKey, resultForKeySubject);
-              this.mutationResults$.next(resultMap);
-            } else {
-              resultForKeySubject == null ? void 0 : resultForKeySubject.next(result);
-            }
-          });
+          mutationForKey.mutation$.subscribe();
           mutationForKey.mutationsSubject.pipe(
             rxjs.distinctUntilChanged(shallowEqual),
             rxjs.skip(1),
             rxjs.filter((items) => items.length === 0)
           ).subscribe(() => {
             mutationForKey == null ? void 0 : mutationForKey.destroy();
-            const resultMap = this.mutationResults$.getValue();
-            resultMap.delete(serializedMutationKey);
-            this.mutationResults$.next(resultMap);
             this.deleteMutationRunnersByKey(serializedMutationKey);
           });
         }
@@ -1806,7 +1870,7 @@ class MutationClient {
   useIsMutating(filters = {}) {
     const predicate = createPredicateForFilters(filters);
     const reduceByNumber = (entries) => entries.reduce((acc, mutation) => {
-      return predicate(mutation) && mutation.stateSubject.getValue().status === "pending" ? 1 + acc : acc;
+      return predicate(mutation) && mutation.state.status === "pending" ? 1 + acc : acc;
     }, 0);
     const lastValue = reduceByNumber(this.mutationsSubject.getValue());
     const value$ = this.mutationsSubject.pipe(
@@ -1826,7 +1890,7 @@ class MutationClient {
     select
   } = {}) {
     const predicate = createPredicateForFilters(filters);
-    const finalSelect = select ?? ((mutation) => mutation.stateSubject.getValue());
+    const finalSelect = select ?? ((mutation) => mutation.state);
     const lastValue = this.mutationsSubject.getValue().reduce((acc, mutation) => {
       const result = [...acc, mutation];
       return result;
@@ -1845,40 +1909,6 @@ class MutationClient {
     );
     return { value$, lastValue };
   }
-  observe({ key }) {
-    var _a;
-    const currentResultValue = (_a = this.mutationResults$.getValue().get(key)) == null ? void 0 : _a.getValue();
-    const mapResultToObservedResult = (value) => ({
-      ...value,
-      isIdle: value.status === "idle",
-      isPaused: false,
-      isError: value.error !== void 0,
-      isPending: false,
-      isSuccess: value.status === "success"
-    });
-    const lastValue = currentResultValue ? mapResultToObservedResult(currentResultValue) : mapResultToObservedResult({
-      data: void 0,
-      error: void 0,
-      status: "idle"
-    });
-    const result$ = this.mutationResults$.pipe(
-      rxjs.switchMap((resultMap) => {
-        const subject = resultMap.get(key);
-        return subject ?? rxjs.EMPTY;
-      })
-    ).pipe(
-      rxjs.filter(isDefined),
-      rxjs.map((value) => ({
-        ...value,
-        isIdle: value.status === "idle",
-        isPaused: false,
-        isError: value.error !== void 0,
-        isPending: false,
-        isSuccess: value.status === "success"
-      }))
-    );
-    return { result$, lastValue };
-  }
   mutate(params) {
     this.mutate$.next(params);
   }
@@ -1892,7 +1922,7 @@ class MutationClient {
   destroy() {
     this.cancel$.complete();
     this.mutate$.complete();
-    this.mutationResults$.complete();
+    this.mutationResultObserver.destroy();
     this.mutationRunnersByKey$.complete();
     this.isMutatingSubject.complete();
     this.mutationsSubject.complete();

package/dist/index.js

@@ -5,7 +5,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import { useRef, useMemo, useCallback, useSyncExternalStore, useEffect, createContext, memo, useContext } from "react";
-import { distinctUntilChanged, tap, finalize, catchError, EMPTY, Subject, identity, BehaviorSubject, map, of, zip, merge, throttleTime, asyncScheduler, switchMap, from, defer, iif, timer, throwError, fromEvent, filter, skip, withLatestFrom, scan, retry, shareReplay, endWith, delay, take, takeUntil, share, startWith, pairwise, mergeMap, NEVER, combineLatest, concatMap as concatMap$1, takeWhile } from "rxjs";
+import { distinctUntilChanged, tap, finalize, catchError, EMPTY, Subject, identity, BehaviorSubject, map, of, zip, merge, throttleTime, asyncScheduler, switchMap, from, defer, iif, timer, throwError, fromEvent, filter, skip, withLatestFrom, scan, retry, shareReplay, endWith, delay, take, takeUntil, share, startWith, pairwise, mergeMap, NEVER, combineLatest, ReplaySubject, concatMap as concatMap$1, takeWhile } from "rxjs";
 import { retryWhen, concatMap, tap as tap$1 } from "rxjs/operators";
 import { jsxs, jsx } from "react/jsx-runtime";
 const useLiveRef = (value) => {
@@ -463,7 +463,9 @@ function useMutation(options, queryClient) {
   const defaultKey = useConstant(() => [nanoid()]);
   const key = serializeKey(options.mutationKey ?? defaultKey.current);
   const observedMutation = useMemo(
-    () => finalQueryClient.mutationClient.observe({ key }),
+    () => finalQueryClient.mutationClient.mutationResultObserver.observe({
+      key
+    }),
     [key]
   );
   const result = useObserve(observedMutation.result$) ?? observedMutation.lastValue;
@@ -1466,47 +1468,38 @@ const dispatchExternalRefetchToAllQueries = ({
   }),
   filter((trigger2) => trigger2.type !== "refetch")
 );
-const mergeResults = (stream$) => stream$.pipe(
-  scan(
-    (acc, current) => {
-      return {
-        ...acc,
-        ...current,
-        data: current.data ?? acc.data,
-        error: current.error ?? acc.error
-      };
-    },
-    {
-      data: void 0,
-      error: void 0,
-      status: "pending"
-    }
-  ),
-  distinctUntilChanged(
-    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
-  )
-);
 const getDefaultMutationState = () => ({
-  context: {},
+  context: void 0,
   data: void 0,
   error: null,
   status: "idle",
   submittedAt: 0,
   variables: void 0
 });
+const mergeResults = (stream$) => stream$.pipe(
+  scan((acc, current) => {
+    return {
+      ...acc,
+      ...current,
+      data: current.data ?? acc.data,
+      error: current.error ?? acc.error
+    };
+  }, getDefaultMutationState()),
+  distinctUntilChanged(
+    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
+  )
+);
 class Mutation {
   constructor({
     args,
     ...options
   }) {
-    __publicField(this, "stateSubject", new BehaviorSubject(
-      getDefaultMutationState()
-    ));
+    __publicField(this, "stateSubject", new ReplaySubject(1));
     /**
      * @important
-     * proxy for rect-query, not really useful
+     * convenience over usage of stateSubject for sync access
      */
-    __publicField(this, "state", this.stateSubject.getValue());
+    __publicField(this, "state", getDefaultMutationState());
     __publicField(this, "options");
     __publicField(this, "mutation$");
     this.options = options;
@@ -1526,11 +1519,13 @@ class Mutation {
         return of({ data: error, isError: true });
       })
     );
-    const loading$ = of({
-      status: "pending"
+    const initState$ = of({
+      ...this.state,
+      status: "pending",
+      submittedAt: (/* @__PURE__ */ new Date()).getTime()
     });
     this.mutation$ = merge(
-      loading$,
+      initState$,
       queryRunner$.pipe(
         map(({ data, isError }) => {
           if (!isError) {
@@ -1646,7 +1641,8 @@ const createMutationRunner = ({
         __queryTriggerHook ?? identity
       );
     }),
-    __queryFinalizeHook ?? identity
+    __queryFinalizeHook ?? identity,
+    shareReplay(1)
   );
   cancel$.subscribe(() => {
     if (mutationsSubject.getValue().length === 0)
@@ -1678,31 +1674,109 @@ const createPredicateForFilters = ({
     serializeKey(mutation.options.mutationKey) !== serializeKey(mutationKey)) {
       return false;
     }
-    if (status && mutation.stateSubject.getValue().status !== status)
+    if (status && mutation.state.status !== status)
       return false;
     return true;
   };
   const finalPredicate = predicate ?? defaultPredicate;
   return finalPredicate;
 };
-class MutationClient {
-  constructor() {
+class MutationResultObserver {
+  constructor(mutationRunnersByKey$) {
     /**
-     * Contain all active mutation for a given key.
-     * A mutation ca have several triggers running (it is not necessarily one function running)
+     * Mutation result subject. It can be used whether there is a mutation
+     * running or not and can be directly observed.
      *
      * @important
      * - automatically cleaned as soon as the last mutation is done for a given key
      */
-    __publicField(this, "mutationRunnersByKey$", new BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField(this, "mutationResults$", new BehaviorSubject(/* @__PURE__ */ new Map()));
+    mutationRunnersByKey$.pipe(
+      switchMap((mapItem) => {
+        const runners = Array.from(mapItem.values()).map((runner) => {
+          const serializedMutationKey = serializeKey(runner.mutationKey);
+          return runner.mutation$.pipe(
+            tap((result) => {
+              this.updateResultForKey({
+                serializedMutationKey,
+                result
+              });
+            }),
+            finalize(() => {
+              this.deleteResultForKey({ serializedMutationKey });
+            })
+          );
+        });
+        return merge(...runners);
+      })
+    ).subscribe();
+  }
+  getDefaultResultValue() {
+    return {
+      ...getDefaultMutationState(),
+      isSuccess: false,
+      isPending: false,
+      isIdle: true,
+      isError: false
+    };
+  }
+  deleteResultForKey({
+    serializedMutationKey
+  }) {
+    const resultMap = this.mutationResults$.getValue();
+    resultMap.delete(serializedMutationKey);
+    this.mutationResults$.next(resultMap);
+  }
+  updateResultForKey({
+    serializedMutationKey,
+    result
+  }) {
+    const resultForKeySubject = this.mutationResults$.getValue().get(serializedMutationKey);
+    const valueForResult = {
+      ...this.getDefaultResultValue(),
+      ...result,
+      isSuccess: result.status === "success",
+      isPending: result.status === "pending",
+      isIdle: result.status === "idle",
+      isError: result.status === "error"
+    };
+    if (!resultForKeySubject) {
+      const resultMap = this.mutationResults$.getValue();
+      resultMap.set(
+        serializedMutationKey,
+        new BehaviorSubject(valueForResult)
+      );
+      this.mutationResults$.next(resultMap);
+    } else {
+      resultForKeySubject == null ? void 0 : resultForKeySubject.next(valueForResult);
+    }
+  }
+  observe({ key }) {
+    var _a;
+    const currentResultValue = (_a = this.mutationResults$.getValue().get(key)) == null ? void 0 : _a.getValue();
+    const lastValue = currentResultValue ?? this.getDefaultResultValue();
+    const result$ = this.mutationResults$.pipe(
+      switchMap((resultMap) => {
+        const subject = resultMap.get(key);
+        return subject ?? EMPTY;
+      })
+    ).pipe(filter(isDefined));
+    return { result$, lastValue };
+  }
+  destroy() {
+    this.mutationResults$.complete();
+  }
+}
+class MutationClient {
+  constructor() {
     /**
-     * Mutation result subject. It can be used whether there is a mutation
-     * running or not and can be directly observed.
+     * 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
      */
-    __publicField(this, "mutationResults$", new BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField(this, "mutationRunnersByKey$", new BehaviorSubject(/* @__PURE__ */ new Map()));
     __publicField(this, "mutate$", new Subject());
     __publicField(this, "cancel$", new Subject());
     /**
@@ -1713,6 +1787,9 @@ class MutationClient {
      * List of all mutations running
      */
     __publicField(this, "mutationsSubject", new BehaviorSubject([]));
+    __publicField(this, "mutationResultObserver", new MutationResultObserver(
+      this.mutationRunnersByKey$
+    ));
     this.mutate$.pipe(
       tap(({ options, args }) => {
         const { mutationKey } = options;
@@ -1726,26 +1803,13 @@ class MutationClient {
             mutationKey
           };
           this.setMutationRunnersByKey(serializedMutationKey, mutationForKey);
-          mutationForKey.mutation$.subscribe((result) => {
-            let resultForKeySubject = this.mutationResults$.getValue().get(serializedMutationKey);
-            if (!resultForKeySubject) {
-              resultForKeySubject = new BehaviorSubject(result);
-              const resultMap = this.mutationResults$.getValue();
-              resultMap.set(serializedMutationKey, resultForKeySubject);
-              this.mutationResults$.next(resultMap);
-            } else {
-              resultForKeySubject == null ? void 0 : resultForKeySubject.next(result);
-            }
-          });
+          mutationForKey.mutation$.subscribe();
           mutationForKey.mutationsSubject.pipe(
             distinctUntilChanged(shallowEqual),
             skip(1),
             filter((items) => items.length === 0)
           ).subscribe(() => {
             mutationForKey == null ? void 0 : mutationForKey.destroy();
-            const resultMap = this.mutationResults$.getValue();
-            resultMap.delete(serializedMutationKey);
-            this.mutationResults$.next(resultMap);
             this.deleteMutationRunnersByKey(serializedMutationKey);
           });
         }
@@ -1804,7 +1868,7 @@ class MutationClient {
   useIsMutating(filters = {}) {
     const predicate = createPredicateForFilters(filters);
     const reduceByNumber = (entries) => entries.reduce((acc, mutation) => {
-      return predicate(mutation) && mutation.stateSubject.getValue().status === "pending" ? 1 + acc : acc;
+      return predicate(mutation) && mutation.state.status === "pending" ? 1 + acc : acc;
     }, 0);
     const lastValue = reduceByNumber(this.mutationsSubject.getValue());
     const value$ = this.mutationsSubject.pipe(
@@ -1824,7 +1888,7 @@ class MutationClient {
     select
   } = {}) {
     const predicate = createPredicateForFilters(filters);
-    const finalSelect = select ?? ((mutation) => mutation.stateSubject.getValue());
+    const finalSelect = select ?? ((mutation) => mutation.state);
     const lastValue = this.mutationsSubject.getValue().reduce((acc, mutation) => {
       const result = [...acc, mutation];
       return result;
@@ -1843,40 +1907,6 @@ class MutationClient {
     );
     return { value$, lastValue };
   }
-  observe({ key }) {
-    var _a;
-    const currentResultValue = (_a = this.mutationResults$.getValue().get(key)) == null ? void 0 : _a.getValue();
-    const mapResultToObservedResult = (value) => ({
-      ...value,
-      isIdle: value.status === "idle",
-      isPaused: false,
-      isError: value.error !== void 0,
-      isPending: false,
-      isSuccess: value.status === "success"
-    });
-    const lastValue = currentResultValue ? mapResultToObservedResult(currentResultValue) : mapResultToObservedResult({
-      data: void 0,
-      error: void 0,
-      status: "idle"
-    });
-    const result$ = this.mutationResults$.pipe(
-      switchMap((resultMap) => {
-        const subject = resultMap.get(key);
-        return subject ?? EMPTY;
-      })
-    ).pipe(
-      filter(isDefined),
-      map((value) => ({
-        ...value,
-        isIdle: value.status === "idle",
-        isPaused: false,
-        isError: value.error !== void 0,
-        isPending: false,
-        isSuccess: value.status === "success"
-      }))
-    );
-    return { result$, lastValue };
-  }
   mutate(params) {
     this.mutate$.next(params);
   }
@@ -1890,7 +1920,7 @@ class MutationClient {
   destroy() {
     this.cancel$.complete();
     this.mutate$.complete();
-    this.mutationResults$.complete();
+    this.mutationResultObserver.destroy();
     this.mutationRunnersByKey$.complete();
     this.isMutatingSubject.complete();
     this.mutationsSubject.complete();

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

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

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

@@ -1,7 +1,8 @@
-import { Subject, BehaviorSubject, type Observable } from "rxjs";
-import { type MutationResult, type MutationOptions, type MutationObservedResult, type MutationFilters, type MutationKey, type MutationState } from "./types";
+import { Subject, BehaviorSubject } from "rxjs";
+import { type MutationOptions, type MutationFilters, type MutationKey, type MutationState } from "./types";
 import { type QueryKey } from "../keys/types";
 import { type Mutation } from "./Mutation";
+import { MutationResultObserver } from "./MutationResultObserver";
 export declare class MutationClient {
     /**
      * Contain all active mutation for a given key.
@@ -11,7 +12,7 @@ export declare class MutationClient {
      * - automatically cleaned as soon as the last mutation is done for a given key
      */
     mutationRunnersByKey$: BehaviorSubject<Map<string, {
-        mutation$: Observable<MutationResult<unknown>>;
+        mutation$: import("rxjs").Observable<MutationState<unknown, unknown, void, unknown>>;
         trigger: ({ args, options }: {
             args: unknown;
             options: MutationOptions<unknown, unknown>;
@@ -23,14 +24,6 @@ export declare class MutationClient {
     } & {
         mutationKey: MutationKey;
     }>>;
-    /**
-     * Mutation result subject. It can be used whether there is a mutation
-     * running or not and can be directly observed.
-     *
-     * @important
-     * - automatically cleaned as soon as the last mutation is done for a given key
-     */
-    mutationResults$: BehaviorSubject<Map<string, BehaviorSubject<MutationResult<any>>>>;
     mutate$: Subject<{
         options: MutationOptions<any, any>;
         args: any;
@@ -46,6 +39,7 @@ export declare class MutationClient {
      * List of all mutations running
      */
     mutationsSubject: BehaviorSubject<Mutation<any>[]>;
+    mutationResultObserver: MutationResultObserver;
     constructor();
     /**
      * @helper
@@ -59,7 +53,7 @@ export declare class MutationClient {
      * @helper
      */
     getMutationRunnersByKey(key: string): ({
-        mutation$: Observable<MutationResult<unknown>>;
+        mutation$: import("rxjs").Observable<MutationState<unknown, unknown, void, unknown>>;
         trigger: ({ args, options }: {
             args: unknown;
             options: MutationOptions<unknown, unknown>;
@@ -72,22 +66,16 @@ export declare class MutationClient {
         mutationKey: MutationKey;
     }) | undefined;
     useIsMutating<TData>(filters?: MutationFilters<TData>): {
-        value$: Observable<number>;
+        value$: import("rxjs").Observable<number>;
         lastValue: number;
     };
     mutationState<TData, Selected = MutationState<TData>>({ filters, select }?: {
         filters?: MutationFilters<TData>;
         select?: (mutation: Mutation<TData>) => Selected;
     }): {
-        value$: Observable<Selected[]>;
+        value$: import("rxjs").Observable<Selected[]>;
         lastValue: Selected[];
     };
-    observe<Result>({ key }: {
-        key: string;
-    }): {
-        result$: Observable<MutationObservedResult<Result>>;
-        lastValue: MutationObservedResult<Result>;
-    };
     mutate<Result, MutationArgs>(params: {
         options: MutationOptions<Result, MutationArgs>;
         args: MutationArgs;

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

@@ -0,0 +1,32 @@
+import { BehaviorSubject, type Observable } from "rxjs";
+import { type MutationKey, type MutationObserverResult, type MutationState } from "./types";
+import { type DefaultError } from "../types";
+import { type createMutationRunner } from "./createMutationRunner";
+export declare class MutationResultObserver {
+    /**
+     * Mutation result subject. It can be used whether there is a mutation
+     * running or not and can be directly observed.
+     *
+     * @important
+     * - automatically cleaned as soon as the last mutation is done for a given key
+     */
+    mutationResults$: BehaviorSubject<Map<string, BehaviorSubject<MutationObserverResult>>>;
+    constructor(mutationRunnersByKey$: BehaviorSubject<Map<string, ReturnType<typeof createMutationRunner> & {
+        mutationKey: MutationKey;
+    }>>);
+    getDefaultResultValue<TData>(): MutationObserverResult<TData>;
+    deleteResultForKey({ serializedMutationKey }: {
+        serializedMutationKey: string;
+    }): void;
+    updateResultForKey<TData, TError = DefaultError>({ serializedMutationKey, result }: {
+        serializedMutationKey: string;
+        result: MutationState<TData, TError>;
+    }): void;
+    observe<Result>({ key }: {
+        key: string;
+    }): {
+        result$: Observable<MutationObserverResult<Result>>;
+        lastValue: MutationObserverResult<Result>;
+    };
+    destroy(): void;
+}

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

@@ -3,7 +3,7 @@ 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<import("./types").MutationResult<unknown>>;
+    mutation$: import("rxjs").Observable<import("./types").MutationState<unknown, unknown, void, unknown>>;
     trigger: ({ args, options }: {
         args: MutationArg;
         options: MutationOptions<T, MutationArg>;

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

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

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

@@ -1,5 +1,5 @@
 import { type MonoTypeOperatorFunction, type Observable } from "rxjs";
-import { type Query, type QueryResult } from "../types";
+import { type DefaultError, type Query, type QueryResult } from "../types";
 import { type Mutation } from "./Mutation";
 /**
  * The default value `merge` is suitable for most use case.
@@ -43,18 +43,6 @@ export interface MutationFilters<TData> {
      */
     status?: MutationStatus;
 }
-export interface MutationResult<R> {
-    data: R | undefined;
-    status: MutationStatus;
-    error: unknown;
-}
-export interface MutationObservedResult<R> extends MutationResult<R> {
-    isError: boolean;
-    isIdle: boolean;
-    isSuccess: boolean;
-    isPending: boolean;
-    isPaused: boolean;
-}
 export type MutationFn<Data, MutationArg> = Observable<Data> | ((arg: MutationArg) => Promise<Data>) | ((arg: MutationArg) => Observable<Data>);
 export interface MutationOptions<Result, MutationArg> {
     enabled?: boolean;
@@ -89,8 +77,71 @@ export interface MutationOptions<Result, MutationArg> {
 export interface MutationState<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> {
     context: TContext | undefined;
     data: TData | undefined;
-    error: TError;
+    error: TError | null;
     status: MutationStatus;
     variables: TVariables | undefined;
     submittedAt: number;
 }
+export interface MutateOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    onSuccess?: (data: TData, variables: TVariables, context: TContext) => void;
+    onError?: (error: TError, variables: TVariables, context: TContext | undefined) => void;
+    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/react/mutations/useMutation.d.ts

@@ -5,14 +5,16 @@ export type AsyncQueryOptions<Result, Params> = Omit<MutationOptions<Result, Par
     cancelOnUnMount?: boolean;
 };
 export declare function useMutation<Args = void, R = undefined>(options: AsyncQueryOptions<R, Args>, queryClient?: QueryClient): {
+    data: R | undefined;
+    error: unknown;
+    variables: void;
     isError: boolean;
     isIdle: boolean;
-    isSuccess: boolean;
     isPending: boolean;
-    isPaused: boolean;
-    data: R | undefined;
+    isSuccess: boolean;
     status: import("../../client/mutations/types").MutationStatus;
-    error: unknown;
+    context: unknown;
+    submittedAt: number;
     mutate: (mutationArgs: Args) => void;
     cancel: () => void;
 };

package/package.json

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