reactjrx 1.60.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;
@@ -481,21 +483,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) {
@@ -1468,43 +1470,112 @@ const dispatchExternalRefetchToAllQueries = ({
   }),
   rxjs.filter((trigger2) => trigger2.type !== "refetch")
 );
+const getDefaultMutationState = () => ({
+  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: void 0,
-      error: void 0,
-      status: "pending"
-    }
-  ),
+  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.ReplaySubject(1));
+    /**
+     * @important
+     * convenience over usage of stateSubject for sync access
+     */
+    __publicField(this, "state", getDefaultMutationState());
+    __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 initState$ = rxjs.of({
+      ...this.state,
+      status: "pending",
+      submittedAt: (/* @__PURE__ */ new Date()).getTime()
+    });
+    this.mutation$ = rxjs.merge(
+      initState$,
+      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 +1585,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 +1621,36 @@ 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
+    __queryFinalizeHook ?? rxjs.identity,
+    rxjs.shareReplay(1)
   );
+  cancel$.subscribe(() => {
+    if (mutationsSubject.getValue().length === 0)
+      return;
+    mutationsSubject.next([]);
+  });
   return {
     mutation$,
     trigger: ({
@@ -1595,36 +1660,138 @@ const createMutationRunner = ({
       mapOperator$.next(options.mapOperator);
       trigger$.next({ args, options });
     },
-    reset$,
+    cancel$,
     destroy,
-    mutationsRunning$,
+    mutationsSubject,
     getClosed: () => closed
   };
 };
-class MutationClient {
-  constructor() {
+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.state.status !== status)
+      return false;
+    return true;
+  };
+  const finalPredicate = predicate ?? defaultPredicate;
+  return finalPredicate;
+};
+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, "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([]));
+    __publicField(this, "mutationResultObserver", new MutationResultObserver(
+      this.mutationRunnersByKey$
+    ));
     this.mutate$.pipe(
       rxjs.tap(({ options, args }) => {
         const { mutationKey } = options;
@@ -1638,53 +1805,45 @@ 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.mutationsRunning$.pipe(
+          mutationForKey.mutation$.subscribe();
+          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();
-            resultMap.delete(serializedMutationKey);
-            this.mutationResults$.next(resultMap);
             this.deleteMutationRunnersByKey(serializedMutationKey);
           });
         }
         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,72 +1867,65 @@ 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.state.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 };
   }
-  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"
-      }))
+  mutationState({
+    filters,
+    select
+  } = {}) {
+    const predicate = createPredicateForFilters(filters);
+    const finalSelect = select ?? ((mutation) => mutation.state);
+    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 { result$, lastValue };
+    return { value$, lastValue };
   }
   mutate(params) {
     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.mutationResultObserver.destroy();
     this.mutationRunnersByKey$.complete();
     this.isMutatingSubject.complete();
+    this.mutationsSubject.complete();
   }
 }
 const createClient = () => {