reactjrx 1.110.0 → 1.112.0

package/dist/index.cjs

@@ -1,41 +1,16 @@
 "use strict";
 var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var _trigger$, _mutationRunner, _currentMutationSubject, _visibility$, _focusedSubject, _client, _currentQuery, _fetchSubject, _currentQueryInitialState, _lastResult, _lastQueryWithDefinedData, _observers, _observerCount, _cancelSubject, _executeSubject, _store, _defaultOptions, _initialState, _notifySubject, _store2, _mutationCache, _queryCache, _mutationDefaults, _queryDefaults, _defaultOptions2;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const React = require("react");
+const react = require("react");
 const rxjs = require("rxjs");
 const operators = require("rxjs/operators");
 const reactQuery = require("@tanstack/react-query");
 const jsxRuntime = require("react/jsx-runtime");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
 const useLiveRef = (value) => {
-  const ref = React.useRef(value);
-  React.useMemo(() => {
+  const ref = react.useRef(value);
+  react.useMemo(() => {
     ref.current = value;
   }, [value]);
   return ref;
@@ -44,12 +19,12 @@ function isPromiseLike(value) {
   return value instanceof Promise || value && typeof value === "object" && "then" in value && typeof value.then === "function" && "catch" in value && value.catch === "function";
 }
 function makeObservable(something) {
-  if (rxjs.isObservable(something)) return something;
-  if (isPromiseLike(something)) return rxjs.from(something);
-  if (typeof something !== "function") return rxjs.of(something);
+  if (rxjs.isObservable(something)) return () => something;
+  if (isPromiseLike(something)) return () => rxjs.from(something);
+  if (typeof something !== "function") return () => rxjs.of(something);
   const somethingAsFunction = something;
-  return rxjs.defer(() => {
-    const result = somethingAsFunction();
+  return (params) => rxjs.defer(() => {
+    const result = somethingAsFunction(params);
     if (isPromiseLike(result)) {
       return rxjs.from(result);
     }
@@ -66,18 +41,18 @@ function useObserve(source$, optionsOrDeps, maybeDeps) {
     compareFn: void 0
   };
   const deps = !maybeDeps && Array.isArray(optionsOrDeps) ? optionsOrDeps : typeof source$ === "function" ? maybeDeps ?? [] : [source$];
-  const valueRef = React.useRef(
+  const valueRef = react.useRef(
     "getValue" in source$ && typeof source$.getValue === "function" ? source$.getValue() : options.defaultValue
   );
   const sourceRef = useLiveRef(source$);
   const optionsRef = useLiveRef(options);
-  const getSnapshot = React.useCallback(() => {
+  const getSnapshot = react.useCallback(() => {
     return valueRef.current;
   }, []);
-  const subscribe = React.useCallback(
+  const subscribe = react.useCallback(
     (next) => {
       const source = sourceRef.current;
-      const sub = makeObservable(source).pipe(
+      const sub = makeObservable(source)().pipe(
         optionsRef.current.defaultValue ? rxjs.startWith(optionsRef.current.defaultValue) : rxjs.identity,
         /**
          * @important there is already a Object.is comparison in place from react
@@ -103,13 +78,13 @@ function useObserve(source$, optionsOrDeps, maybeDeps) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [...deps]
   );
-  const result = React.useSyncExternalStore(subscribe, getSnapshot);
+  const result = react.useSyncExternalStore(subscribe, getSnapshot);
   return result;
 }
 function useSubscribe(source, deps = []) {
   const sourceRef = useLiveRef(source);
-  React.useEffect(() => {
-    const sub = makeObservable(sourceRef.current).pipe(
+  react.useEffect(() => {
+    const sub = makeObservable(sourceRef.current)().pipe(
       rxjs.catchError((error) => {
         console.error(error);
         return rxjs.EMPTY;
@@ -125,11 +100,11 @@ function useSubscribe(source, deps = []) {
   ]);
 }
 const useConstant = (fn) => {
-  const ref = React.useRef();
+  const ref = react.useRef(void 0);
   if (!ref.current) {
     ref.current = fn();
   }
-  React.useEffect(() => {
+  react.useEffect(() => {
     if (process.env.NODE_ENV === "development") ;
   }, []);
   return ref;
@@ -139,10 +114,10 @@ const useSubject = ({
   completeOnUnmount = true
 } = {}) => {
   const subject = useConstant(() => new rxjs.Subject());
-  const completed = React.useRef(false);
+  const completed = react.useRef(false);
   const onBeforeCompleteRef = useLiveRef(onBeforeComplete);
   const completeOnUnmountRef = useLiveRef(completeOnUnmount);
-  React.useEffect(() => {
+  react.useEffect(() => {
     if (completed.current) {
       subject.current = new rxjs.Subject();
       completed.current = false;
@@ -163,7 +138,7 @@ const useSubject = ({
 };
 const useObservableCallback = () => {
   const subject = useSubject();
-  const trigger = React.useCallback(
+  const trigger = react.useCallback(
     (arg) => {
       subject.current.next(arg);
     },
@@ -174,9 +149,9 @@ const useObservableCallback = () => {
 };
 const useBehaviorSubject = (state) => {
   const subject = useConstant(() => new rxjs.BehaviorSubject(state));
-  const completed = React.useRef(false);
-  const stateRef = React.useRef(state);
-  React.useEffect(() => {
+  const completed = react.useRef(false);
+  const stateRef = react.useRef(state);
+  react.useEffect(() => {
     if (completed.current) {
       subject.current = new rxjs.BehaviorSubject(stateRef.current);
       completed.current = false;
@@ -193,7 +168,7 @@ const useBehaviorSubject = (state) => {
 const useObservableState = (defaultValue) => {
   const subject = useBehaviorSubject(defaultValue);
   const subject$ = useLiveRef(subject.current.asObservable());
-  const setState = React.useCallback(
+  const setState = react.useCallback(
     (value) => {
       subject.current.next(value);
     },
@@ -204,11 +179,32 @@ const useObservableState = (defaultValue) => {
 };
 const useLiveBehaviorSubject = (state) => {
   const subject = useBehaviorSubject(state);
-  React.useEffect(() => {
+  react.useEffect(() => {
     subject.current.next(state);
   }, [state, subject]);
   return subject;
 };
+function useSubscribeEffect(source, unsafeOptions, deps = []) {
+  const options = unsafeOptions != null && !Array.isArray(unsafeOptions) ? unsafeOptions : {};
+  const retryOption = options.retry ?? true;
+  const onErrorRef = useLiveRef(
+    options.onError ?? ((error) => {
+      console.error(error);
+    })
+  );
+  const sourceAsObservable = react.useCallback(() => makeObservable(source)(), deps);
+  const enhancerMakeObservable = react.useCallback(
+    () => sourceAsObservable().pipe(
+      rxjs.catchError((error) => {
+        onErrorRef.current(error);
+        throw error;
+      }),
+      retryOption ? rxjs.retry() : rxjs.identity
+    ),
+    [sourceAsObservable, retryOption, onErrorRef]
+  );
+  useSubscribe(enhancerMakeObservable, deps);
+}
 const SIGNAL_RESET = Symbol("SIGNAL_RESET");
 function signal(config = {}) {
   const normalizedConfig = {
@@ -286,7 +282,7 @@ function useSignalValue(signal2, selector) {
   );
 }
 const useSignal = (config) => {
-  const [stateSignal] = React.useState(() => signal(config));
+  const [stateSignal] = react.useState(() => signal(config));
   const value = useSignalValue(stateSignal);
   return [value, stateSignal];
 };
@@ -555,7 +551,7 @@ const useUnmountObservable = () => {
   return subject;
 };
 const useEffectOnce = (effect) => {
-  React.useEffect(effect, []);
+  react.useEffect(effect, []);
 };
 const useMount = (fn) => {
   useEffectOnce(() => {
@@ -709,23 +705,23 @@ class QueryClient$ {
     });
   }
 }
-const Context$1 = React.createContext(void 0);
-const QueryClientProvider$ = React.memo(
+const Context = react.createContext(void 0);
+const QueryClientProvider$ = react.memo(
   ({
     children,
-    client: _client2
+    client: _client
   }) => {
-    const [client] = React.useState(() => _client2 ?? new QueryClient$());
-    React.useEffect(() => {
+    const [client] = react.useState(() => _client ?? new QueryClient$());
+    react.useEffect(() => {
       return () => {
         client.destroy();
       };
     }, [client]);
-    return /* @__PURE__ */ jsxRuntime.jsx(Context$1.Provider, { value: client, children });
+    return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value: client, children });
   }
 );
 const useQueryClient$ = () => {
-  const client = React.useContext(Context$1);
+  const client = react.useContext(Context);
   if (!client) {
     throw new Error(
       "useReactJrxQueryClient must be used within a ReactJrxQueryProvider"
@@ -801,34 +797,33 @@ function useMutation$(options, queryClient) {
     isSuccess: false,
     isIdle: true
   });
-  const mutationFnAsync = (variables) => {
-    let lastData;
-    return new Promise((resolve, reject) => {
-      const source = typeof options.mutationFn === "function" ? options.mutationFn(variables) : options.mutationFn;
-      source.pipe(rxjs.take(1)).subscribe({
-        next: (data) => {
-          lastData = { value: data };
-        },
-        error: (error) => {
-          reject(error);
-        },
-        complete: () => {
-          if (lastData === void 0)
-            return reject(new Error("Stream completed without any data"));
-          resolve(lastData.value);
-        }
-      });
-    });
-  };
   const result = reactQuery.useMutation(
     {
       ...options,
-      mutationFn: mutationFnAsync
+      mutationFn: (variables) => {
+        let lastData;
+        return new Promise((resolve, reject) => {
+          const source = typeof options.mutationFn === "function" ? options.mutationFn(variables) : options.mutationFn;
+          source.pipe(rxjs.take(1)).subscribe({
+            next: (data) => {
+              lastData = { value: data };
+            },
+            error: (error) => {
+              reject(error);
+            },
+            complete: () => {
+              if (lastData === void 0)
+                return reject(new Error("Stream completed without any data"));
+              resolve(lastData.value);
+            }
+          });
+        });
+      }
     },
     queryClient
   );
   const { status, isPending, isError, isSuccess, isIdle } = result;
-  React.useEffect(() => {
+  react.useEffect(() => {
     stateSubject.current.next({ status, isPending, isError, isSuccess, isIdle });
   }, [status, isPending, isError, isSuccess, isIdle, stateSubject]);
   return { ...result, state$: stateSubject.current };
@@ -845,14 +840,14 @@ function useSwitchMutation$(options, queryClient) {
     },
     queryClient
   );
-  const mutateSwitch = React.useCallback(
+  const mutateSwitch = react.useCallback(
     (variables) => {
       cancel();
-      mutate(variables);
+      return mutate(variables);
     },
     [mutate, cancel]
   );
-  const mutateAsyncSwitch = React.useCallback(
+  const mutateAsyncSwitch = react.useCallback(
     (variables) => {
       cancel();
       return mutateAsync(variables);
@@ -861,2758 +856,67 @@ function useSwitchMutation$(options, queryClient) {
   );
   return { ...rest, mutate: mutateSwitch, mutateAsync: mutateAsyncSwitch };
 }
-function hasObjectPrototype(o) {
-  return Object.prototype.toString.call(o) === "[object Object]";
-}
-function isPlainObject(o) {
-  if (!hasObjectPrototype(o)) {
-    return false;
-  }
-  const ctor = o.constructor;
-  if (typeof ctor === "undefined") {
-    return true;
-  }
-  const prot = ctor.prototype;
-  if (!hasObjectPrototype(prot)) {
-    return false;
-  }
-  if (!prot.hasOwnProperty("isPrototypeOf")) {
-    return false;
-  }
-  return true;
-}
-const hashKey = (queryKey) => {
-  return JSON.stringify(
-    queryKey,
-    (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
-      result[key] = val[key];
-      return result;
-    }, {}) : val
-  );
-};
-const nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
-  byte &= 63;
-  if (byte < 36) {
-    id += byte.toString(36);
-  } else if (byte < 62) {
-    id += (byte - 26).toString(36).toUpperCase();
-  } else if (byte > 62) {
-    id += "-";
-  } else {
-    id += "_";
-  }
-  return id;
-}, "");
-const getDefaultMutationState = () => ({
-  context: void 0,
-  data: void 0,
-  error: null,
-  status: "idle",
-  submittedAt: 0,
-  variables: void 0,
-  failureCount: 0,
-  failureReason: null,
-  isPaused: false
-});
-function trackSubscriptions(onCountUpdate) {
-  let count = 0;
-  return function refCountOperatorFunction(source) {
-    return new rxjs.Observable((observer) => {
-      count++;
-      const sub = source.subscribe(observer);
-      onCountUpdate(count);
-      return () => {
-        count--;
-        onCountUpdate(count);
-        sub.unsubscribe();
-      };
-    });
-  };
-}
-const observeUntilFinished = (source) => source.pipe(
-  rxjs.takeWhile(
-    (result) => result.status !== "error" && result.status !== "success",
-    true
-  )
-);
-class MutationRunner {
-  constructor({
-    __queryFinalizeHook
-  } = {}) {
-    __privateAdd(this, _trigger$, new rxjs.Subject());
-    __publicField(this, "state$");
-    const refCountSubject = new rxjs.BehaviorSubject(0);
-    const noMoreObservers$ = refCountSubject.pipe(
-      rxjs.filter((value) => value === 0)
-    );
-    this.state$ = __privateGet(this, _trigger$).pipe(
-      rxjs.concatMap(({ args, mutation, options }) => {
-        const mapOperator = options.mapOperator ?? "merge";
-        const mergeTrigger$ = __privateGet(this, _trigger$).pipe(
-          rxjs.filter(() => mapOperator === "merge")
-        );
-        const switchTrigger$ = __privateGet(this, _trigger$).pipe(
-          rxjs.filter(() => mapOperator === "switch"),
-          rxjs.tap(() => {
-            mutation.cancel();
-          })
-        );
-        const deferExecution$ = rxjs.defer(() => {
-          mutation.execute(args);
-          return rxjs.EMPTY;
-        });
-        const resetState$ = mutation.state$.pipe(
-          observeUntilFinished,
-          rxjs.last(),
-          rxjs.mergeMap(() => mutation.state$),
-          rxjs.takeUntil(__privateGet(this, _trigger$))
-        );
-        const stateUntilFinished$ = mutation.state$.pipe(
-          observeUntilFinished,
-          rxjs.skip(1)
-        );
-        const observeUntil$ = rxjs.merge(
-          noMoreObservers$,
-          mergeTrigger$,
-          switchTrigger$,
-          mutation.cancelled$
-        );
-        return rxjs.merge(
-          stateUntilFinished$,
-          resetState$,
-          /**
-           * We defer execution so that we return at least
-           * the current state first (same mechanism is used for query)
-           */
-          deferExecution$
-        ).pipe(
-          rxjs.map((state) => ({ state, mutation })),
-          __queryFinalizeHook ?? rxjs.identity,
-          rxjs.takeUntil(observeUntil$)
+function useContactMutation$(options, queryClient) {
+  const client = reactQuery.useQueryClient(queryClient);
+  const mutationKey = options.mutationKey;
+  const { mutateAsync, ...rest } = useMutation$(
+    {
+      ...options,
+      onMutate({ variables }) {
+        var _a;
+        return (_a = options.onMutate) == null ? void 0 : _a.call(options, variables);
+      },
+      onSuccess(data, variables, context) {
+        var _a;
+        return (_a = options.onSuccess) == null ? void 0 : _a.call(options, data, variables.variables, context);
+      },
+      onError(error, variables, context) {
+        var _a;
+        return (_a = options.onError) == null ? void 0 : _a.call(options, error, variables.variables, context);
+      },
+      onSettled(data, error, variables, context) {
+        var _a;
+        return (_a = options.onSettled) == null ? void 0 : _a.call(options, data, error, variables.variables, context);
+      },
+      mutationFn: ({ ready$, variables }) => {
+        const source = typeof options.mutationFn === "function" ? options.mutationFn(variables) : options.mutationFn;
+        return ready$.pipe(
+          rxjs.filter((isReady) => isReady),
+          rxjs.first(),
+          rxjs.switchMap(() => source)
         );
-      }),
-      rxjs.shareReplay({
-        refCount: true,
-        bufferSize: 1
-      }),
-      trackSubscriptions((count) => {
-        refCountSubject.next(count);
-      })
-    );
-  }
-  trigger({
-    args,
-    options,
-    mutation
-  }) {
-    __privateGet(this, _trigger$).next({ args, options, mutation });
-  }
-}
-_trigger$ = new WeakMap();
-function partialMatchKey(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (typeof a !== typeof b) {
-    return false;
-  }
-  if (a && b && typeof a === "object" && typeof b === "object") {
-    return !Object.keys(b).some((key) => !partialMatchKey(a[key], b[key]));
-  }
-  return false;
-}
-const matchKey = (keyA, keyB, { exact = false } = {}) => {
-  if (exact) {
-    return hashKey(keyA) === hashKey(keyB);
-  }
-  return partialMatchKey(keyA, keyB);
-};
-const distinctUntilStateChanged = (stream) => stream.pipe(
-  rxjs.distinctUntilChanged(
-    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
-  )
-);
-class MutationObserver {
-  constructor(client, options = {}, mutationRunner) {
-    __privateAdd(this, _mutationRunner);
-    __privateAdd(this, _currentMutationSubject, new rxjs.BehaviorSubject(void 0));
-    /**
-     * @important
-     * Used to maintain persistance to latest mutation. This ensure
-     * - mutation does not get garbage collected
-     * - mutation mutate options are run on finish
-     */
-    __publicField(this, "observed$");
-    __publicField(this, "getObserverResultFromState", (state) => {
-      return {
-        ...getDefaultMutationState(),
-        ...state,
-        isSuccess: state.status === "success",
-        isPending: state.status === "pending",
-        isIdle: state.status === "idle",
-        isError: state.status === "error",
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        mutate: this.mutate,
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        reset: this.reset
-      };
-    });
-    var _a;
-    this.client = client;
-    this.options = options;
-    this.options.mutationKey = ((_a = this.options) == null ? void 0 : _a.mutationKey) ?? [nanoid()];
-    __privateSet(this, _mutationRunner, mutationRunner ?? new MutationRunner(this.options));
-    this.mutate = this.mutate.bind(this);
-    this.reset = this.reset.bind(this);
-    __privateGet(this, _currentMutationSubject).pipe(
-      rxjs.filter(isDefined),
-      rxjs.mergeMap(
-        (mutation) => __privateGet(this, _mutationRunner).state$.pipe(
-          rxjs.takeUntil(
-            mutation.mutation.state$.pipe(observeUntilFinished, rxjs.last())
-          )
-        )
-      )
-    ).subscribe();
-    this.observed$ = __privateGet(this, _currentMutationSubject).pipe(
-      rxjs.switchMap((maybeMutation) => {
-        return (maybeMutation == null ? void 0 : maybeMutation.mutation.state$.pipe(
-          // last(),
-          rxjs.map((state) => ({
-            state,
-            options: maybeMutation.options
-          }))
-        )) ?? rxjs.EMPTY;
-      }),
-      rxjs.tap(({ state, options: options2 }) => {
-        if (state.status === "error") {
-          (options2 == null ? void 0 : options2.onError) && (options2 == null ? void 0 : options2.onError(
-            state.error,
-            state.variables,
-            state.context
-          ));
-          (options2 == null ? void 0 : options2.onSettled) && (options2 == null ? void 0 : options2.onSettled(
-            state.data,
-            state.error,
-            state.variables,
-            state.context
-          ));
-        }
-        if (state.status === "success") {
-          (options2 == null ? void 0 : options2.onSuccess) && (options2 == null ? void 0 : options2.onSuccess(
-            state.data,
-            state.variables,
-            state.context
-          ));
-          (options2 == null ? void 0 : options2.onSettled) && (options2 == null ? void 0 : options2.onSettled(
-            state.data,
-            state.error,
-            state.variables,
-            state.context
-          ));
-        }
-      }),
-      rxjs.ignoreElements()
-    );
-  }
-  setOptions(options) {
-    var _a;
-    const prevOptions = this.options;
-    this.options = this.client.defaultMutationOptions({
-      mutationKey: this.options.mutationKey,
-      ...options
-    });
-    const currentMutation = (_a = __privateGet(this, _currentMutationSubject).getValue()) == null ? void 0 : _a.mutation;
-    if (this.options.mutationKey && prevOptions.mutationKey && !matchKey(this.options.mutationKey, prevOptions.mutationKey, {
-      exact: true
-    })) {
-      this.reset();
-    } else {
-      currentMutation == null ? void 0 : currentMutation.setOptions(this.options);
-    }
-  }
-  observe() {
-    var _a;
-    const lastValue = this.getObserverResultFromState(
-      ((_a = __privateGet(this, _currentMutationSubject).getValue()) == null ? void 0 : _a.mutation.state) ?? getDefaultMutationState()
-    );
-    const mutationResult$ = __privateGet(this, _mutationRunner).state$.pipe(
-      rxjs.distinctUntilChanged(
-        ({ mutation: prevMutation, state: { data: prevData, ...prev } }, { mutation: currentMutation, state: { data: currData, ...curr } }) => prevMutation === currentMutation && shallowEqual(prev, curr) && shallowEqual(prevData, currData)
-      ),
-      rxjs.map(({ state }) => state),
-      rxjs.scan((acc, current) => {
-        return {
-          ...acc,
-          ...current,
-          ...current.status === "pending" && {
-            data: current.data ?? acc.data
-          },
-          ...current.status === "pending" && {
-            error: current.error ?? acc.error
-          }
-        };
-      }),
-      rxjs.map((state) => this.getObserverResultFromState(state))
-    );
-    const defaultStateOnMutationCancel$ = __privateGet(this, _currentMutationSubject).pipe(
-      rxjs.filter(isDefined),
-      rxjs.switchMap((mutation) => mutation.mutation.cancelled$),
-      rxjs.map(() => this.getObserverResultFromState(getDefaultMutationState()))
-    );
-    const result$ = rxjs.merge(
-      this.observed$,
-      mutationResult$,
-      defaultStateOnMutationCancel$
-    ).pipe(distinctUntilStateChanged);
-    return { result$, lastValue };
-  }
-  /**
-   * @important
-   * Compliance react-query only
-   */
-  subscribe(subscription) {
-    const sub = this.observe().result$.subscribe((result) => {
-      subscription(result);
-    });
-    return () => {
-      sub.unsubscribe();
-    };
-  }
-  async mutate(variables, options = {}) {
-    const mutation = this.client.getMutationCache().build(this.client, this.options);
-    __privateGet(this, _currentMutationSubject).next({ mutation, options });
-    __privateGet(this, _mutationRunner).trigger({
-      args: variables,
-      options: this.options,
-      mutation
-    });
-    return await new Promise((resolve, reject) => {
-      mutation.state$.pipe(observeUntilFinished, rxjs.last()).subscribe({
-        error: (error) => {
-          reject(error);
-        },
-        next: (data) => {
-          if (data.error) {
-            reject(data.error);
-          } else {
-            resolve(data.data);
-          }
-        }
-      });
-    });
-  }
-  getCurrentResult() {
-    var _a;
-    const mutation = this.client.getMutationCache().find({ exact: true, mutationKey: (_a = this.options) == null ? void 0 : _a.mutationKey });
-    return this.getObserverResultFromState(
-      (mutation == null ? void 0 : mutation.state) ?? getDefaultMutationState()
-    );
-  }
-  reset() {
-    const { mutation } = __privateGet(this, _currentMutationSubject).getValue() ?? {};
-    __privateGet(this, _currentMutationSubject).next(void 0);
-    mutation == null ? void 0 : mutation.cancel();
-  }
-}
-_mutationRunner = new WeakMap();
-_currentMutationSubject = new WeakMap();
-const Context = React.createContext(void 0);
-const ClientEffect = ({ client }) => {
-  React.useEffect(() => {
-    client.mount();
-    return () => {
-      client.unmount();
-    };
-  }, [client]);
-  return null;
-};
-const QueryClientProvider = React.memo(
-  ({ children, client }) => {
-    const value = React.useMemo(() => client, [client]);
-    return /* @__PURE__ */ jsxRuntime.jsxs(Context.Provider, { value, children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ClientEffect, { client }),
-      children
-    ] });
-  }
-);
-const useQueryClient = (queryClient) => {
-  const client = React.useContext(Context);
-  if (queryClient) {
-    return queryClient;
-  }
-  if (!client) {
-    throw new Error("No QueryClient set, use QueryClientProvider to set one");
-  }
-  return client;
-};
-function noop() {
-}
-function useMutation(options, queryClient) {
-  const defaultQueryClient = useQueryClient(queryClient);
-  const optionsRef = useLiveRef(options);
-  const defaultKey = useConstant(() => [nanoid()]);
-  const serializedKey = hashKey(options.mutationKey ?? defaultKey.current);
-  const [mutationObserver] = React.useState(
-    () => new MutationObserver(
-      defaultQueryClient,
-      options
-    )
-  );
-  React.useEffect(() => {
-    mutationObserver.setOptions(options);
-  }, [mutationObserver, options]);
-  const observedMutation = React.useMemo(() => {
-    return mutationObserver.observe();
-  }, [serializedKey, mutationObserver]);
-  const result = useObserve(observedMutation.result$) ?? observedMutation.lastValue;
-  const mutate = React.useCallback(
-    (variables, mutateOptions) => {
-      mutationObserver.mutate(variables, mutateOptions).catch(noop);
+      }
     },
-    [mutationObserver]
+    queryClient
   );
-  React.useEffect(() => {
-    return () => {
-      if (optionsRef.current.cancelOnUnMount) {
-        mutationObserver.reset();
-      }
-    };
-  }, [mutationObserver, optionsRef]);
-  return { ...result, mutate, mutateAsync: result.mutate };
-}
-function emitToSubject(subject) {
-  return (source$) => source$.pipe(
-    operators.tap((value) => {
-      subject.next(value);
-    })
+  const mutateAsyncConcat = react.useCallback(
+    async (variables) => {
+      const mutations = client.getMutationCache().findAll({
+        mutationKey,
+        exact: true
+      });
+      const subject = new rxjs.BehaviorSubject(false);
+      const result = mutateAsync({ variables, ready$: subject });
+      await Promise.all(
+        mutations.map((mutation) => mutation.continue().catch(rxjs.noop))
+      );
+      subject.next(true);
+      return await result.finally(() => {
+        subject.complete();
+      });
+    },
+    [mutateAsync, client, mutationKey]
   );
-}
-class OnlineManager {
-  constructor() {
-    __publicField(this, "isOnlineSubject", new rxjs.BehaviorSubject(true));
-    __publicField(this, "online$", this.isOnlineSubject.pipe(rxjs.distinctUntilChanged()));
-    __publicField(this, "backToOnline$", this.online$.pipe(
-      rxjs.filter((isOnline) => isOnline),
-      rxjs.first()
-    ));
-    rxjs.merge(
-      isServer ? rxjs.EMPTY : rxjs.fromEvent(window, "offline").pipe(rxjs.map(() => false)),
-      isServer ? rxjs.EMPTY : rxjs.fromEvent(window, "online").pipe(rxjs.map(() => true))
-    ).pipe(emitToSubject(this.isOnlineSubject)).subscribe();
-  }
-  isOnline() {
-    return this.isOnlineSubject.getValue();
-  }
-  setOnline(online) {
-    const changed = this.isOnlineSubject.getValue() !== online;
-    if (changed) {
-      this.isOnlineSubject.next(online);
-    }
-  }
-}
-const onlineManager = new OnlineManager();
-function isStale(query, options) {
-  return query.isStaleByTime(options.staleTime);
-}
-function shouldLoadOnMount(query, options) {
-  return options.enabled !== false && !query.state.dataUpdatedAt && !(query.state.status === "error" && options.retryOnMount === false) && query.state.fetchStatus !== "fetching";
-}
-function shouldFetchOnMount(query, options) {
-  return shouldLoadOnMount(query, options) || query.state.dataUpdatedAt > 0 && shouldFetchOn(query, options, options.refetchOnMount);
-}
-function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
-  return query.state.fetchStatus !== "fetching" && options.enabled !== false && (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
-}
-function shouldFetchOnWindowFocus(query, options) {
-  return shouldFetchOn(query, options, options.refetchOnWindowFocus);
-}
-function shouldFetchOn(query, options, field) {
-  if (options.enabled !== false) {
-    const value = typeof field === "function" ? field(query) : field;
-    if (value === "idle") {
-      return query.state.fetchStatus === "idle";
-    }
-    return value === "always" || value !== false && isStale(query, options);
-  }
-  return false;
-}
-function canFetch(networkMode) {
-  return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
-}
-function filterObjectByKey(obj, keys) {
-  return keys.reduce(
-    (acc, key) => {
-      if (key in obj) {
-        return { ...acc, [key]: obj[key] };
-      }
-      return acc;
+  const mutateConcat = react.useCallback(
+    (variables) => {
+      mutateAsyncConcat(variables).catch(rxjs.noop);
     },
-    {}
+    [mutateAsyncConcat]
   );
+  return { ...rest, mutate: mutateConcat, mutateAsync: mutateAsyncConcat };
 }
-function isPlainArray(value) {
-  return Array.isArray(value) && value.length === Object.keys(value).length;
-}
-function replaceEqualDeep(a, b) {
-  if (a === b) {
-    return a;
-  }
-  const array = isPlainArray(a) && isPlainArray(b);
-  if (array || isPlainObject(a) && isPlainObject(b)) {
-    const aItems = array ? a : Object.keys(a);
-    const aSize = aItems.length;
-    const bItems = array ? b : Object.keys(b);
-    const bSize = bItems.length;
-    const copy = array ? [] : {};
-    let equalItems = 0;
-    for (let i = 0; i < bSize; i++) {
-      const key = array ? i : bItems[i];
-      if (!array && a[key] === void 0 && b[key] === void 0 && aItems.includes(key)) {
-        copy[key] = void 0;
-        equalItems++;
-      } else {
-        copy[key] = replaceEqualDeep(a[key], b[key]);
-        if (copy[key] === a[key] && a[key] !== void 0) {
-          equalItems++;
-        }
-      }
-    }
-    return aSize === bSize && equalItems === aSize ? a : copy;
-  }
-  return b;
-}
-function hashQueryKeyByOptions(queryKey, options) {
-  const hashFn = (options == null ? void 0 : options.queryKeyHashFn) ?? hashKey;
-  return hashFn(queryKey);
-}
-function matchQuery(filters, query) {
-  const {
-    type = "all",
-    exact,
-    fetchStatus,
-    predicate,
-    queryKey,
-    stale
-  } = filters;
-  if (queryKey) {
-    if (exact) {
-      if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
-        return false;
-      }
-    } else if (!partialMatchKey(query.queryKey, queryKey)) {
-      return false;
-    }
-  }
-  if (type !== "all") {
-    const isActive = query.isActive();
-    if (type === "active" && !isActive) {
-      return false;
-    }
-    if (type === "inactive" && isActive) {
-      return false;
-    }
-  }
-  if (typeof stale === "boolean" && query.isStale() !== stale) {
-    return false;
-  }
-  if (typeof fetchStatus !== "undefined" && fetchStatus !== query.state.fetchStatus) {
-    return false;
-  }
-  if (predicate && !predicate(query)) {
-    return false;
-  }
-  return true;
-}
-function timeUntilStale(updatedAt, staleTime) {
-  return Math.max(updatedAt + (staleTime ?? 0) - Date.now(), 0);
-}
-function functionalUpdate(updater, input) {
-  return typeof updater === "function" ? updater(input) : updater;
-}
-function replaceData(prevData, data, options) {
-  if (typeof options.structuralSharing === "function") {
-    return options.structuralSharing(prevData, data);
-  } else if (options.structuralSharing !== false) {
-    return replaceEqualDeep(prevData, data);
-  }
-  return data;
-}
-const skipToken = Symbol();
-const reduceState = ({
-  getOptions,
-  getState,
-  initialState
-}) => (source) => source.pipe(
-  rxjs.scan((acc, { command, state: current }) => {
-    if (command === "reset") return { ...acc, ...current };
-    if (command === "cancel") {
-      const status2 = acc.status === "pending" ? "pending" : current.status ?? acc.status;
-      return { ...acc, ...current, status: status2 };
-    }
-    const currentData = current.data;
-    const weHaveNewData = currentData !== void 0 && currentData !== acc.data;
-    const weHaveDataKeyInCurrent = "data" in current;
-    const newSuccessStatus = current.status === "success";
-    const hasData = acc.data !== void 0;
-    const hasError = acc.error !== void 0 || acc.error !== null;
-    const status = current.status ?? acc.status;
-    const newData = weHaveNewData ? replaceData(getState().data, currentData, getOptions()) : weHaveDataKeyInCurrent ? current.data : acc.data;
-    const previousStatusIsSuccessOrError = acc.status === "error" || acc.status === "success";
-    const errorUpdateCount = current.status === "error" && (acc.status === "error" && acc.fetchStatus === "fetching" || acc.status !== "error") ? acc.errorUpdateCount + 1 : acc.errorUpdateCount;
-    const dataUpdateCount = weHaveNewData ? acc.dataUpdateCount + 1 : current.dataUpdateCount ?? acc.dataUpdateCount;
-    const newPendingStatusOnHold = current.status === "pending" && previousStatusIsSuccessOrError && // (dataUpdateCount !== 0 || errorUpdateCount !== 0)
-    (hasData || hasError);
-    const error = status === "pending" ? null : current.error ?? acc.error;
-    return {
-      ...acc,
-      ...current,
-      status,
-      error,
-      errorUpdateCount,
-      ...newSuccessStatus && {
-        isInvalidated: false
-      },
-      data: newData,
-      dataUpdateCount,
-      ...newPendingStatusOnHold && {
-        status: acc.status
-      }
-    };
-  }, initialState)
-);
-const isQueryFinished = (source) => source.pipe(
-  rxjs.map(
-    ({ status, fetchStatus }) => fetchStatus === "idle" && (status === "success" || status === "error")
-  )
-);
-const takeUntilFinished = (source) => source.pipe(
-  rxjs.takeWhile((result) => {
-    const isFetchingOrPaused = result.fetchStatus !== "idle";
-    return isFetchingOrPaused;
-  }, true)
-);
-class FocusManager {
-  constructor() {
-    __privateAdd(this, _visibility$, rxjs.merge(
-      isServer ? rxjs.EMPTY : rxjs.fromEvent(document, "visibilitychange"),
-      isServer ? rxjs.EMPTY : rxjs.fromEvent(window, "visibilitychange")
-    ).pipe(rxjs.map(() => document.visibilityState)));
-    __privateAdd(this, _focusedSubject, new rxjs.BehaviorSubject(
-      isServer ? true : document.visibilityState === "visible"
-    ));
-    // public readonly focused$ = this.#focusedSubject.pipe(distinctUntilChanged())
-    __publicField(this, "focused$", __privateGet(this, _focusedSubject));
-    __publicField(this, "focusRegained$", this.focused$.pipe(
-      rxjs.skip(1),
-      rxjs.filter((visibility) => visibility)
-    ));
-    __privateGet(this, _visibility$).pipe(
-      rxjs.tap((value) => {
-        __privateGet(this, _focusedSubject).next(value === "visible");
-      })
-    ).subscribe();
-  }
-  isFocused() {
-    return __privateGet(this, _focusedSubject).getValue();
-  }
-  setFocused(focused) {
-    const changed = __privateGet(this, _focusedSubject).getValue() !== (focused ?? true);
-    if (changed) {
-      __privateGet(this, _focusedSubject).next(focused ?? true);
-    }
-  }
-  subscribe(fn) {
-    const sub = this.focused$.subscribe(fn);
-    return () => {
-      sub.unsubscribe();
-    };
-  }
-  /**
-   * @important
-   * You do not need that outside of testing. This is bad practice but necessary in order
-   * to not mess too much with rq tests files.
-   *
-   * Use it after mocking to force the manager to hold mocked value.
-   */
-  refresh() {
-    document.dispatchEvent(new Event("visibilitychange"));
-  }
-}
-_visibility$ = new WeakMap();
-_focusedSubject = new WeakMap();
-const focusManager = new FocusManager();
-const whenNewData = (source) => source.pipe(
-  rxjs.filter((state) => state.status === "success"),
-  rxjs.map((state) => ({
-    data: state.data,
-    status: state.status,
-    dataUpdatedAt: state.dataUpdatedAt
-  })),
-  rxjs.distinctUntilChanged(shallowEqual)
-);
-class QueryObserver {
-  constructor(client, options) {
-    __privateAdd(this, _client);
-    __privateAdd(this, _currentQuery);
-    __privateAdd(this, _fetchSubject, new rxjs.Subject());
-    /**
-     * Used to subscribe to changes in either query or options (or both).
-     * We need to be able to track change to both of them at the same time
-     * in order to react accordingly and in order (such as refetch on options change)
-     */
-    __publicField(this, "queryUpdateSubject", new rxjs.Subject());
-    /**
-     * Mostly used to compare the state before and after mount
-     */
-    __privateAdd(this, _currentQueryInitialState);
-    /**
-     * Mostly used for internal optimization such as not
-     * running selectors twice, etc
-     */
-    __privateAdd(this, _lastResult);
-    // This property keeps track of the last query with defined data.
-    // It will be used to pass the previous data and query to the placeholder function between renders.
-    __privateAdd(this, _lastQueryWithDefinedData);
-    __privateAdd(this, _observers, 0);
-    __publicField(this, "getObserverResultFromQuery", ({
-      options,
-      query,
-      optimisticResult,
-      prevResult: {
-        result: prevResult,
-        options: prevResultOptions,
-        state: prevResultState,
-        select: prevSelect,
-        selectError: prevSelectError,
-        selectResult: prevSelectResult
-      }
-    }) => {
-      var _a;
-      const state = query.state;
-      const isPending = query.state.status === "pending";
-      const prevQuery = __privateGet(this, _currentQuery);
-      const prevOptions = this.options;
-      const queryChange = query !== prevQuery;
-      const queryInitialState = queryChange ? query.state : __privateGet(this, _currentQueryInitialState);
-      let { errorUpdatedAt, fetchStatus, error } = state;
-      if (optimisticResult) {
-        const mounted = !!__privateGet(this, _observers);
-        const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
-        const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
-        if (fetchOnMount || fetchOptionally) {
-          fetchStatus = canFetch(query.options.networkMode) ? "fetching" : "paused";
-        }
-      }
-      const isLoading = isPending && fetchStatus === "fetching";
-      let data;
-      let selectError = prevSelectError;
-      let selectFn = prevSelect ?? null;
-      let selectResult = prevSelectResult;
-      if (options.select && typeof state.data !== "undefined") {
-        if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === prevSelect) {
-          data = prevSelectResult;
-        } else {
-          try {
-            selectFn = options.select;
-            data = options.select(state.data);
-            data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
-            selectResult = data;
-            selectError = null;
-          } catch (error2) {
-            data = prevSelectResult;
-            selectError = error2;
-          }
-        }
-      } else {
-        data = state.data;
-        selectError = null;
-      }
-      let status = fetchStatus !== "idle" && !state.dataUpdatedAt ? "pending" : state.status;
-      if (selectError) {
-        error = selectError;
-        data = prevSelectResult;
-        errorUpdatedAt = (prevResult == null ? void 0 : prevResult.errorUpdatedAt) ?? errorUpdatedAt;
-        status = "error";
-      }
-      const isError = status === "error";
-      let isPlaceholderData = false;
-      if (typeof options.placeholderData !== "undefined" && typeof data === "undefined" && status === "pending") {
-        let placeholderData;
-        if ((prevResult == null ? void 0 : prevResult.isPlaceholderData) && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
-          placeholderData = prevResult.data;
-        } else {
-          placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(
-            (_a = __privateGet(this, _lastQueryWithDefinedData)) == null ? void 0 : _a.state.data,
-            __privateGet(this, _lastQueryWithDefinedData)
-          ) : options.placeholderData;
-          if (options.select && typeof placeholderData !== "undefined") {
-            try {
-              placeholderData = options.select(placeholderData);
-            } catch (selectError2) {
-            }
-          }
-        }
-        if (typeof placeholderData !== "undefined") {
-          status = "success";
-          data = replaceData(
-            prevResult == null ? void 0 : prevResult.data,
-            placeholderData,
-            options
-          );
-          isPlaceholderData = true;
-        }
-      }
-      const isFetching = fetchStatus === "fetching";
-      const result = {
-        status,
-        fetchStatus,
-        isPending,
-        isSuccess: status === "success",
-        isError,
-        isInitialLoading: isLoading,
-        isLoading,
-        data,
-        dataUpdatedAt: state.dataUpdatedAt,
-        error,
-        errorUpdatedAt,
-        failureCount: state.fetchFailureCount,
-        failureReason: state.fetchFailureReason,
-        errorUpdateCount: state.errorUpdateCount,
-        isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,
-        isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,
-        isFetching,
-        isRefetching: isFetching && !isPending,
-        isLoadingError: isError && state.dataUpdatedAt === 0,
-        isPaused: fetchStatus === "paused",
-        isPlaceholderData,
-        isRefetchError: isError && state.dataUpdatedAt !== 0,
-        isStale: isStale(query, options),
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        refetch: this.refetch
-      };
-      return {
-        result,
-        selectError,
-        select: selectFn,
-        selectResult
-      };
-    });
-    this.options = options;
-    __privateSet(this, _client, client);
-    this.bindMethods();
-    __privateSet(this, _currentQuery, this.setOptions(options));
-    const query = __privateGet(this, _currentQuery);
-    __privateSet(this, _currentQueryInitialState, query.state);
-    const { result, select } = this.getObserverResultFromQuery({
-      query,
-      options: this.options,
-      prevResult: {
-        options: this.options,
-        state: query.state
-      }
-    });
-    __privateSet(this, _lastResult, {
-      state: query.state,
-      options,
-      result,
-      select
-    });
-  }
-  bindMethods() {
-    this.refetch = this.refetch.bind(this);
-  }
-  setOptions(options) {
-    const prevOptions = this.options;
-    this.options = __privateGet(this, _client).defaultQueryOptions(options);
-    if (!shallowEqual(this.options, prevOptions)) {
-      __privateGet(this, _client).getQueryCache().notify({
-        type: "observerOptionsUpdated",
-        query: __privateGet(this, _currentQuery),
-        observer: this
-      });
-    }
-    if (typeof this.options.enabled !== "undefined" && typeof this.options.enabled !== "boolean") {
-      throw new Error("Expected enabled to be a boolean");
-    }
-    const query = this.buildQuery(this.options);
-    if (query !== __privateGet(this, _currentQuery)) {
-      __privateSet(this, _currentQueryInitialState, query.state);
-      __privateSet(this, _currentQuery, query);
-    }
-    this.queryUpdateSubject.next({
-      options: this.options,
-      query
-    });
-    return query;
-  }
-  buildQuery(options) {
-    const query = __privateGet(this, _client).getQueryCache().build(__privateGet(this, _client), options);
-    if (!query.options.queryFn && this.options.queryFn) {
-      query.setOptions(options);
-    }
-    return query;
-  }
-  getCurrentResult() {
-    const result = this.getObserverResultFromQuery({
-      options: this.options,
-      prevResult: __privateGet(this, _lastResult),
-      query: __privateGet(this, _currentQuery)
-    });
-    return result.result;
-  }
-  getCurrentQuery() {
-    return __privateGet(this, _currentQuery);
-  }
-  getOptimisticResult(options) {
-    const query = this.buildQuery(options);
-    const observedResult = this.getObserverResultFromQuery({
-      query,
-      options,
-      optimisticResult: true,
-      prevResult: __privateGet(this, _lastResult)
-    });
-    if (shouldAssignObserverCurrentProperties(this, observedResult.result)) {
-      this.updateResult({ query, ...observedResult });
-    }
-    return observedResult.result;
-  }
-  updateResult({
-    query,
-    result,
-    selectError,
-    select,
-    selectResult
-  }) {
-    __privateGet(this, _lastResult).state = query.state;
-    __privateGet(this, _lastResult).result = result;
-    __privateGet(this, _lastResult).selectResult = selectResult;
-    if (selectError !== void 0) {
-      __privateGet(this, _lastResult).selectError = selectError;
-    }
-    if (select !== void 0) {
-      __privateGet(this, _lastResult).select = select;
-    }
-    __privateGet(this, _lastResult).options = this.options;
-    if (query.state.data !== void 0) {
-      __privateSet(this, _lastQueryWithDefinedData, query);
-    }
-    __privateGet(this, _client).getQueryCache().notify({
-      query: __privateGet(this, _currentQuery),
-      type: "observerResultsUpdated"
-    });
-  }
-  async refetch({ ...options } = {}) {
-    return await this.fetch({
-      ...options
-    });
-  }
-  async fetch(fetchOptions) {
-    const query = this.buildQuery(this.options);
-    if (query !== __privateGet(this, _currentQuery)) {
-      __privateSet(this, _currentQuery, query);
-      __privateSet(this, _currentQueryInitialState, query.state);
-      this.queryUpdateSubject.next({
-        options: this.options,
-        query
-      });
-    }
-    const finalFetchOptions = {
-      ...fetchOptions,
-      cancelRefetch: (fetchOptions == null ? void 0 : fetchOptions.cancelRefetch) ?? true
-    };
-    __privateGet(this, _currentQuery).fetch(this.options, finalFetchOptions).catch(rxjs.noop);
-    __privateGet(this, _fetchSubject).next({
-      query,
-      fetchOptions: finalFetchOptions
-    });
-    await query.getFetchResultAsPromise();
-    const { result } = this.getObserverResultFromQuery({
-      query,
-      options: this.options,
-      prevResult: __privateGet(this, _lastResult)
-    });
-    return result;
-  }
-  /**
-   * feature parity with rq, not used internally
-   */
-  subscribe(listener) {
-    const sub = this.observe().subscribe(listener);
-    return () => {
-      sub.unsubscribe();
-    };
-  }
-  observe() {
-    const observedQuery = __privateGet(this, _currentQuery);
-    const currentQuery$ = this.queryUpdateSubject.pipe(
-      rxjs.map(({ query }) => query),
-      rxjs.startWith(__privateGet(this, _currentQuery)),
-      rxjs.distinctUntilChanged()
-    );
-    const watchForImplicitRefetch$ = this.queryUpdateSubject.pipe(
-      rxjs.startWith({
-        query: __privateGet(this, _currentQuery),
-        options: this.options
-      }),
-      rxjs.pairwise(),
-      rxjs.tap(
-        ([{ options: prevOptions, query: prevQuery }, { options, query }]) => {
-          if (shouldFetchOptionally(query, prevQuery, options, prevOptions)) {
-            this.fetch().catch(rxjs.noop);
-          }
-        }
-      ),
-      rxjs.ignoreElements()
-    );
-    const observedQuery$ = currentQuery$.pipe(
-      rxjs.switchMap((query) => query.observe(this)),
-      rxjs.ignoreElements()
-    );
-    const result$ = rxjs.merge(
-      /**
-       * It's important to observe the query before we subscribe to its result
-       * later in the chain of merge to get the first result right after fetch
-       */
-      observedQuery$,
-      watchForImplicitRefetch$,
-      currentQuery$.pipe(
-        rxjs.switchMap((query) => {
-          const options = this.options;
-          const options$ = this.queryUpdateSubject.pipe(
-            rxjs.startWith({ query, options }),
-            rxjs.filter((update) => update.query === query),
-            rxjs.map((update) => update.options),
-            rxjs.distinctUntilChanged(),
-            rxjs.shareReplay(1)
-          );
-          const queryFetch$ = __privateGet(this, _fetchSubject).pipe(
-            rxjs.filter((update) => update.query === query)
-          );
-          const currentQueryIsStale$ = query.state$.pipe(
-            whenNewData,
-            rxjs.switchMap(
-              (state) => this.options.staleTime === Infinity ? rxjs.NEVER : (this.options.staleTime ?? 0) <= 0 ? rxjs.of(state).pipe(rxjs.delay(1)) : rxjs.timer(this.options.staleTime ?? 1)
-            ),
-            rxjs.takeWhile(() => this.options.enabled ?? true)
-          );
-          const comparisonFunction = (objA, objB) => {
-            const notifyOnChangeProps = options.notifyOnChangeProps;
-            const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
-            const reducedFunction = Array.isArray(notifyOnChangePropsValue) ? notifyOnChangePropsValue.length === 0 ? () => true : (objA2, objB2) => {
-              const reducedObjA = filterObjectByKey(
-                objA2,
-                notifyOnChangePropsValue
-              );
-              const reducedObjB = filterObjectByKey(
-                objB2,
-                notifyOnChangePropsValue
-              );
-              return shallowEqual(reducedObjA, reducedObjB);
-            } : shallowEqual;
-            return reducedFunction(objA, objB);
-          };
-          const queryInternallyFetchedUpdate$ = queryFetch$.pipe(
-            rxjs.switchMap(() => query.state$),
-            takeUntilFinished
-          );
-          const refetchInterval$ = options$.pipe(
-            rxjs.map(({ refetchInterval, refetchIntervalInBackground }) => {
-              const computedRefetchInterval = (typeof refetchInterval === "function" ? refetchInterval(__privateGet(this, _currentQuery)) : refetchInterval) ?? false;
-              return {
-                refetchInterval: computedRefetchInterval,
-                refetchIntervalInBackground
-              };
-            }),
-            rxjs.distinctUntilChanged(shallowEqual),
-            rxjs.switchMap(({ refetchInterval, refetchIntervalInBackground }) => {
-              return !refetchInterval ? rxjs.NEVER : rxjs.interval(refetchInterval).pipe(
-                rxjs.tap(() => {
-                  if (
-                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-                    refetchIntervalInBackground || focusManager.isFocused()
-                  ) {
-                    this.fetch({ cancelRefetch: false }).catch(rxjs.noop);
-                  }
-                })
-              );
-            }),
-            rxjs.ignoreElements()
-          );
-          const isMaybeEnabled$ = options$.pipe(
-            rxjs.map(({ enabled }) => enabled ?? true),
-            rxjs.distinctUntilChanged()
-          );
-          const disabled$ = isMaybeEnabled$.pipe(
-            rxjs.filter((enabled) => !enabled),
-            rxjs.map(() => query.state)
-          );
-          const onFocusRegain$ = isMaybeEnabled$.pipe(
-            rxjs.filter((enabled) => enabled),
-            rxjs.switchMap(() => focusManager.focusRegained$),
-            rxjs.withLatestFrom(options$),
-            rxjs.tap(([, options2]) => {
-              if (shouldFetchOnWindowFocus(query, options2)) {
-                this.fetch({ cancelRefetch: false }).catch(rxjs.noop);
-              }
-            }),
-            rxjs.ignoreElements()
-          );
-          const stateObservedOnDisabled$ = disabled$.pipe(
-            rxjs.map(() => query.state)
-          );
-          const updateResult = (source) => {
-            return source.pipe(
-              rxjs.withLatestFrom(options$),
-              rxjs.map(([, currentOptions]) => {
-                const result = this.getObserverResultFromQuery({
-                  query,
-                  options: currentOptions,
-                  prevResult: __privateGet(this, _lastResult)
-                });
-                this.updateResult({ query, ...result });
-                return result.result;
-              })
-            );
-          };
-          const stateUpdate$ = rxjs.merge(
-            stateObservedOnDisabled$,
-            queryInternallyFetchedUpdate$,
-            query.state$,
-            // options$,
-            currentQueryIsStale$
-          );
-          const observedResult$ = stateUpdate$.pipe(
-            updateResult,
-            // This one ensure we don't re-trigger same state
-            rxjs.distinctUntilChanged(shallowEqual),
-            // This one make sure we dispatch based on user preference
-            rxjs.distinctUntilChanged(comparisonFunction)
-          );
-          return rxjs.merge(refetchInterval$, onFocusRegain$, observedResult$);
-        })
-      ).pipe(
-        trackSubscriptions((count) => __privateSet(this, _observers, count)),
-        rxjs.tap({
-          subscribe: () => {
-            if (shouldFetchOnMount(observedQuery, this.options)) {
-              this.fetch().catch(rxjs.noop);
-            }
-          }
-        })
-      )
-    );
-    return result$;
-  }
-  destroy() {
-  }
-}
-_client = new WeakMap();
-_currentQuery = new WeakMap();
-_fetchSubject = new WeakMap();
-_currentQueryInitialState = new WeakMap();
-_lastResult = new WeakMap();
-_lastQueryWithDefinedData = new WeakMap();
-_observers = new WeakMap();
-function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
-  if (!shallowEqual(observer.getCurrentResult(), optimisticResult)) {
-    return true;
-  }
-  return false;
-}
-const IsRestoringContext = React__namespace.createContext(false);
-const useIsRestoring = () => React__namespace.useContext(IsRestoringContext);
-IsRestoringContext.Provider;
-function createValue() {
-  let isReset = false;
-  return {
-    clearReset: () => {
-      isReset = false;
-    },
-    reset: () => {
-      isReset = true;
-    },
-    isReset: () => {
-      return isReset;
-    }
-  };
-}
-const QueryErrorResetBoundaryContext = React__namespace.createContext(createValue());
-const useQueryErrorResetBoundary = () => React__namespace.useContext(QueryErrorResetBoundaryContext);
-function shouldThrowError(throwError, params) {
-  if (typeof throwError === "function") {
-    return throwError(...params);
-  }
-  return !!throwError;
-}
-const getHasError = ({
-  result,
-  errorResetBoundary,
-  throwOnError,
-  query
-}) => {
-  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && shouldThrowError(throwOnError, [result.error, query]);
-};
-function useBaseQuery(options, Observer, queryClient) {
-  if (process.env.NODE_ENV !== "production") {
-    if (typeof options !== "object" || Array.isArray(options)) {
-      throw new Error(
-        'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
-      );
-    }
-  }
-  const client = useQueryClient(queryClient);
-  const isRestoring = useIsRestoring();
-  const errorResetBoundary = useQueryErrorResetBoundary();
-  const defaultedOptions = client.defaultQueryOptions(options);
-  defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
-  const [observer] = React.useState(
-    () => new Observer(
-      client,
-      defaultedOptions
-    )
-  );
-  const result$ = useConstant(() => observer.observe());
-  const optimisticResult = useLiveRef(
-    observer.getOptimisticResult(defaultedOptions)
-  );
-  const result = optimisticResult.current;
-  useObserve(
-    () => result$.current.pipe(
-      /**
-       * By the time this observer runs the result may have changed (eg: synchronous setData).
-       * It's important to not skip the first result (even tho most of the time they are equal).
-       * We only skip if they are the same.
-       */
-      rxjs.filter((result2) => !shallowEqual(result2, optimisticResult.current))
-    ),
-    []
-  );
-  React.useEffect(() => {
-    observer.setOptions(defaultedOptions);
-  }, [defaultedOptions, observer]);
-  const error = result.error;
-  if (error && getHasError({
-    result,
-    errorResetBoundary,
-    throwOnError: defaultedOptions.throwOnError,
-    query: client.getQueryCache().get(defaultedOptions.queryHash)
-  })) {
-    throw error;
-  }
-  return optimisticResult.current;
-}
-function useQuery(options, queryClient) {
-  return useBaseQuery(options, QueryObserver, queryClient);
-}
-function useForeverQuery(options, queryClient) {
-  return useBaseQuery(
-    {
-      refetchOnMount: "idle",
-      refetchOnReconnect: false,
-      refetchInterval: false,
-      refetchOnWindowFocus: false,
-      ...options
-    },
-    QueryObserver,
-    queryClient
-  );
-}
-function useSubscribeEffect(source, unsafeOptions, deps = []) {
-  const options = unsafeOptions != null && !Array.isArray(unsafeOptions) ? unsafeOptions : {};
-  const retryOption = options.retry ?? true;
-  const onErrorRef = useLiveRef(
-    options.onError ?? ((error) => {
-      console.error(error);
-    })
-  );
-  const sourceAsObservable = React.useCallback(() => makeObservable(source), deps);
-  const enhancerMakeObservable = React.useCallback(
-    () => sourceAsObservable().pipe(
-      rxjs.catchError((error) => {
-        onErrorRef.current(error);
-        throw error;
-      }),
-      retryOption ? rxjs.retry() : rxjs.identity
-    ),
-    [sourceAsObservable, retryOption, onErrorRef]
-  );
-  useSubscribe(enhancerMakeObservable, deps);
-}
-const delayWhenNetworkOnline = () => (source) => {
-  return rxjs.merge(
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    rxjs.of({ isPaused: true }),
-    onlineManager.backToOnline$.pipe(
-      rxjs.mergeMap(
-        () => (
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          rxjs.merge(rxjs.of({ isPaused: false }), source)
-        )
-      )
-    )
-  );
-};
-const waitForNetworkOnError = (source) => {
-  let attempt = 0;
-  return source.pipe(
-    rxjs.catchError((error) => {
-      attempt++;
-      if (attempt <= 1 && !onlineManager.isOnline()) {
-        return rxjs.merge(
-          rxjs.of({
-            failureCount: attempt,
-            failureReason: error
-          }),
-          /**
-           * @important
-           * timer needed to be iso RQ, so the state returned by mutation include both previous and next one
-           */
-          rxjs.timer(1).pipe(
-            rxjs.mergeMap(
-              () => rxjs.throwError(() => error).pipe(delayWhenNetworkOnline())
-            )
-          )
-        );
-      } else {
-        return rxjs.throwError(() => error);
-      }
-    })
-  );
-};
-const executeMutation = ({
-  variables,
-  state,
-  options
-}) => {
-  const isPaused = state.isPaused;
-  const defaultFn = async () => await Promise.reject(new Error("No mutationFn found"));
-  const mutationFn = options.mutationFn ?? defaultFn;
-  const onMutateFactory = () => {
-    var _a;
-    return ((_a = options.onMutate) == null ? void 0 : _a.call(options, variables)) ?? void 0;
-  };
-  const contextFromOnMutate$ = makeObservable(onMutateFactory);
-  contextFromOnMutate$.pipe(
-    rxjs.tap((context) => {
-      if (context === void 0) {
-        throw new Error("onMutate returned undefined");
-      }
-    })
-  );
-  const rawContext$ = rxjs.of(state.context);
-  const context$ = rxjs.iif(() => isPaused, rawContext$, contextFromOnMutate$).pipe(
-    rxjs.shareReplay(1)
-  );
-  const onError = (error, context, attempt) => {
-    const onError$ = makeObservable(
-      () => {
-        var _a;
-        return (_a = options.onError) == null ? void 0 : _a.call(options, error, variables, context);
-      }
-    );
-    return onError$.pipe(
-      rxjs.catchError(() => rxjs.of(error)),
-      rxjs.map(
-        () => ({
-          failureCount: attempt,
-          error,
-          failureReason: error,
-          context,
-          status: "error"
-        })
-      )
-    );
-  };
-  const queryRunner$ = context$.pipe(
-    rxjs.switchMap((context) => {
-      const fn$ = typeof mutationFn === "function" ? makeObservable(() => mutationFn(variables)) : mutationFn;
-      const sharedFn$ = fn$.pipe(rxjs.share());
-      const completeWithoutValue$ = sharedFn$.pipe(
-        rxjs.isEmpty(),
-        rxjs.tap((isEmppty) => {
-          if (isEmppty) {
-            throw new Error("Mutation completed without any emission (EMPTY)");
-          }
-        }),
-        rxjs.ignoreElements()
-      );
-      const finalFn$ = rxjs.merge(sharedFn$, completeWithoutValue$).pipe(
-        rxjs.map(
-          (data) => ({
-            result: {
-              data
-            },
-            error: null,
-            context
-          })
-        ),
-        waitForNetworkOnError,
-        retryBackoff({
-          ...options,
-          retry: (attempt, error) => {
-            const retry = options.retry ?? 0;
-            if (typeof retry === "function") return retry(attempt, error);
-            if (typeof retry === "boolean") return retry;
-            return attempt < retry;
-          },
-          caughtError: (attempt, error) => (
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            rxjs.of({
-              failureCount: attempt,
-              failureReason: error
-            })
-          ),
-          catchError: (attempt, error) => onError(error, context, attempt).pipe(
-            rxjs.map((data) => ({
-              ...data,
-              result: void 0
-            }))
-          )
-        }),
-        rxjs.takeWhile(
-          ({ result, error }) => (result == null ? void 0 : result.data) === void 0 && error === void 0,
-          true
-        )
-      );
-      if (onlineManager.isOnline() || options.networkMode === "offlineFirst" || options.networkMode === "always") {
-        return finalFn$;
-      } else {
-        return finalFn$.pipe(delayWhenNetworkOnline());
-      }
-    })
-  );
-  const initState$ = rxjs.of({
-    ...state,
-    variables,
-    status: "pending",
-    isPaused: false,
-    failureCount: 0,
-    failureReason: null,
-    submittedAt: state.submittedAt ?? (/* @__PURE__ */ new Date()).getTime()
-  });
-  const mutation$ = rxjs.merge(
-    initState$,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    context$.pipe(rxjs.map((context) => ({ context }))),
-    queryRunner$.pipe(
-      rxjs.switchMap(({ result: mutationData, error, ...restState }) => {
-        if (!mutationData && !error)
-          return rxjs.of({
-            ...restState
-          });
-        const success$ = error ? rxjs.of(null) : makeObservable(
-          () => {
-            var _a;
-            return (_a = options.onSuccess) == null ? void 0 : _a.call(
-              options,
-              mutationData == null ? void 0 : mutationData.data,
-              variables,
-              restState.context
-            );
-          }
-        );
-        const onOptionSettled$ = makeObservable(
-          () => {
-            var _a;
-            return (_a = options.onSettled) == null ? void 0 : _a.call(
-              options,
-              mutationData == null ? void 0 : mutationData.data,
-              error,
-              variables,
-              restState.context
-            );
-          }
-        );
-        const settled$ = onOptionSettled$.pipe(
-          rxjs.catchError((error2) => mutationData ? rxjs.of(mutationData) : rxjs.of(error2))
-        );
-        const result$ = rxjs.concat(success$, settled$).pipe(
-          rxjs.toArray(),
-          rxjs.map(
-            () => error ? {
-              error,
-              data: void 0,
-              variables,
-              ...restState
-            } : {
-              status: "success",
-              error,
-              data: mutationData == null ? void 0 : mutationData.data,
-              variables,
-              failureCount: 0,
-              failureReason: null,
-              ...restState
-            }
-          ),
-          rxjs.catchError(
-            (error2) => onError(error2, restState.context, 0).pipe(
-              rxjs.map((data) => ({
-                ...data,
-                data: void 0
-              }))
-            )
-          )
-        );
-        return result$;
-      })
-    )
-  ).pipe(
-    rxjs.scan((acc, current) => {
-      return {
-        ...acc,
-        ...current,
-        data: current.data ?? acc.data,
-        error: current.error ?? acc.error
-      };
-    }, getDefaultMutationState())
-  );
-  return mutation$;
-};
-class Mutation {
-  constructor({
-    options,
-    mutationCache,
-    state
-  }) {
-    __privateAdd(this, _observerCount, new rxjs.BehaviorSubject(0));
-    __privateAdd(this, _cancelSubject, new rxjs.Subject());
-    __privateAdd(this, _executeSubject, new rxjs.Subject());
-    __publicField(this, "state", getDefaultMutationState());
-    __publicField(this, "state$");
-    __publicField(this, "options");
-    __publicField(this, "observerCount$", __privateGet(this, _observerCount).asObservable());
-    __publicField(this, "cancelled$", __privateGet(this, _cancelSubject).asObservable());
-    this.options = options;
-    this.state = state ?? this.state;
-    const resetPendingState$ = __privateGet(this, _cancelSubject).pipe(
-      rxjs.filter(() => this.state.status === "pending"),
-      rxjs.map(() => ({
-        status: "idle"
-      }))
-    );
-    const executionState$ = __privateGet(this, _executeSubject).pipe(
-      rxjs.switchMap(
-        (variables) => executeMutation({
-          options: {
-            ...this.options,
-            onMutate: (variables2) => {
-              const onCacheMutate$ = makeObservable(
-                () => {
-                  var _a, _b;
-                  return (_b = (_a = mutationCache.config).onMutate) == null ? void 0 : _b.call(
-                    _a,
-                    variables2,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    this
-                  );
-                }
-              );
-              const optionsOnMutate = () => {
-                var _a, _b;
-                return (_b = (_a = this.options).onMutate) == null ? void 0 : _b.call(_a, variables2);
-              };
-              const onOptionMutate$ = makeObservable(optionsOnMutate);
-              const context$ = onCacheMutate$.pipe(
-                rxjs.mergeMap(() => onOptionMutate$)
-              );
-              return context$;
-            },
-            onError: (error, variables2, context) => {
-              const onCacheError$ = makeObservable(
-                () => {
-                  var _a, _b;
-                  return (_b = (_a = mutationCache.config).onError) == null ? void 0 : _b.call(
-                    _a,
-                    error,
-                    variables2,
-                    context,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    this
-                  );
-                }
-              );
-              const onOptionError$ = makeObservable(
-                () => {
-                  var _a, _b;
-                  return (_b = (_a = this.options).onError) == null ? void 0 : _b.call(_a, error, variables2, context);
-                }
-              );
-              return rxjs.concat(onCacheError$, onOptionError$).pipe(rxjs.toArray());
-            },
-            onSettled: (data, error, variables2, context) => {
-              const onCacheSuccess$ = makeObservable(
-                () => {
-                  var _a, _b;
-                  return (_b = (_a = mutationCache.config).onSettled) == null ? void 0 : _b.call(
-                    _a,
-                    data,
-                    error,
-                    variables2,
-                    context,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    this
-                  );
-                }
-              );
-              const onOptionSettled$ = makeObservable(
-                () => {
-                  var _a, _b;
-                  return (_b = (_a = this.options).onSettled) == null ? void 0 : _b.call(_a, data, error, variables2, context);
-                }
-              );
-              return rxjs.concat(onCacheSuccess$, onOptionSettled$).pipe(rxjs.toArray());
-            },
-            onSuccess: (data, variables2, context) => {
-              const onCacheSuccess$ = makeObservable(
-                () => {
-                  var _a, _b;
-                  return (_b = (_a = mutationCache.config).onSuccess) == null ? void 0 : _b.call(
-                    _a,
-                    data,
-                    variables2,
-                    context,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    this
-                  );
-                }
-              );
-              const onOptionSuccess$ = makeObservable(
-                () => {
-                  var _a, _b;
-                  return (_b = (_a = this.options).onSuccess) == null ? void 0 : _b.call(_a, data, variables2, context);
-                }
-              );
-              return rxjs.concat(onCacheSuccess$, onOptionSuccess$).pipe(rxjs.toArray());
-            }
-          },
-          state: this.state,
-          variables
-        }).pipe(rxjs.takeUntil(__privateGet(this, _cancelSubject)))
-      )
-    );
-    const stateChange$ = rxjs.merge(resetPendingState$, executionState$);
-    this.state$ = stateChange$.pipe(
-      rxjs.startWith(this.state),
-      rxjs.scan(
-        (acc, partialState) => ({
-          ...acc,
-          ...partialState
-        }),
-        this.state
-      ),
-      distinctUntilStateChanged,
-      rxjs.tap((value) => {
-        this.state = value;
-      }),
-      rxjs.shareReplay(1),
-      trackSubscriptions((count) => {
-        __privateGet(this, _observerCount).next(count);
-      })
-    );
-  }
-  get meta() {
-    return this.options.meta;
-  }
-  setOptions(options) {
-    this.options = { ...this.options, ...options };
-  }
-  /**
-   * @important
-   * The resulting observable will complete as soon as the mutation
-   * is over, unlike the state which can be re-subscribed later.
-   */
-  execute(variables) {
-    __privateGet(this, _executeSubject).next(variables);
-    __privateGet(this, _executeSubject).complete();
-    return this.state$.pipe(observeUntilFinished);
-  }
-  continue() {
-    return this.execute(this.state.variables);
-  }
-  /**
-   * Cancel if needed and finalize the mutation.
-   * The mutation will be garbage collected automatically
-   * when no more observers are listening
-   */
-  cancel() {
-    __privateGet(this, _cancelSubject).next();
-    __privateGet(this, _cancelSubject).complete();
-  }
-}
-_observerCount = new WeakMap();
-_cancelSubject = new WeakMap();
-_executeSubject = new WeakMap();
-const createPredicateForFilters = ({
-  mutationKey,
-  status,
-  predicate,
-  exact = true
-} = {}) => {
-  const finalPredicate = (mutation) => {
-    if (exact && mutationKey !== void 0 && mutation.options.mutationKey !== void 0 && !matchKey(mutation.options.mutationKey, mutationKey, { exact })) {
-      return false;
-    }
-    if (!exact && mutationKey !== void 0 && mutation.options.mutationKey !== void 0 && !matchKey(mutation.options.mutationKey, mutationKey, { exact })) {
-      return false;
-    }
-    if (status && mutation.state.status !== status) return false;
-    if (predicate) {
-      return predicate(mutation);
-    }
-    return true;
-  };
-  return finalPredicate;
-};
-class Store {
-  constructor() {
-    /**
-     * @important
-     * Query store. Could be turned into a map for more performance.
-     */
-    __publicField(this, "entriesSubject", new rxjs.BehaviorSubject([]));
-    __publicField(this, "changeSubject", new rxjs.Subject());
-    __publicField(this, "entries$", this.entriesSubject.pipe(rxjs.share()));
-    __publicField(this, "added$", this.changeSubject.pipe(
-      rxjs.filter(({ type }) => type === "added"),
-      rxjs.map(({ entity }) => entity),
-      rxjs.share()
-    ));
-    __publicField(this, "removed$", this.changeSubject.pipe(
-      rxjs.filter(({ type }) => type === "removed"),
-      rxjs.map(({ entity }) => entity),
-      rxjs.share()
-    ));
-    __publicField(this, "stateChange$", rxjs.merge(
-      this.entriesSubject.pipe(
-        rxjs.first(),
-        rxjs.mergeMap((entities) => rxjs.from(entities))
-      ),
-      this.added$
-    ).pipe(
-      rxjs.mergeMap(
-        (entity) => entity.state$.pipe(
-          rxjs.map(() => entity),
-          rxjs.takeUntil(
-            this.removed$.pipe(
-              rxjs.filter((removedMutation) => removedMutation === entity)
-            )
-          )
-        )
-      ),
-      rxjs.share()
-    ));
-  }
-  getValues() {
-    return this.entriesSubject.getValue();
-  }
-  remove(entity) {
-    this.entriesSubject.next(
-      this.entriesSubject.getValue().filter((toRemove) => entity !== toRemove)
-    );
-    this.changeSubject.next({ type: "removed", entity });
-  }
-  add(entity) {
-    this.entriesSubject.next([...this.entriesSubject.getValue(), entity]);
-    this.changeSubject.next({ type: "added", entity });
-  }
-  find(predicate) {
-    return this.entriesSubject.getValue().find(predicate);
-  }
-}
-class MutationCache {
-  constructor(config = {}) {
-    __privateAdd(this, _store, new Store());
-    this.config = config;
-  }
-  build(client, options, state) {
-    const mutation = new Mutation({
-      mutationCache: this,
-      options: client.defaultMutationOptions(options),
-      state
-    });
-    mutation.state$.pipe(
-      /**
-       * Once a mutation is finished and there are no more observers than us
-       * we start the process of cleaning it up based on gc settings
-       */
-      rxjs.filter(({ status }) => status === "success" || status === "error"),
-      rxjs.switchMap(
-        () => mutation.observerCount$.pipe(
-          rxjs.filter((count) => count <= 1),
-          rxjs.take(1)
-        )
-      ),
-      // defaults to 5mn
-      rxjs.switchMap(() => {
-        return rxjs.timer(mutation.options.gcTime ?? 5 * 60 * 1e3);
-      }),
-      rxjs.take(1)
-    ).subscribe({
-      complete: () => {
-        this.remove(mutation);
-      }
-    });
-    __privateGet(this, _store).add(mutation);
-    return mutation;
-  }
-  getAll() {
-    return this.findAll();
-  }
-  remove(mutationToRemove) {
-    const toRemove = __privateGet(this, _store).getValues().find((mutation) => {
-      return mutation === mutationToRemove;
-    });
-    toRemove == null ? void 0 : toRemove.cancel();
-    __privateGet(this, _store).remove(mutationToRemove);
-  }
-  find(filters) {
-    const defaultedFilters = { exact: true, ...filters };
-    const predicate = createPredicateForFilters(defaultedFilters);
-    return __privateGet(this, _store).getValues().find((mutation) => predicate(mutation));
-  }
-  findAll(filters = {}) {
-    const defaultedFilters = { exact: true, ...filters };
-    const predicate = createPredicateForFilters(defaultedFilters);
-    return __privateGet(this, _store).getValues().filter((mutation) => predicate(mutation)).map((mutation) => mutation);
-  }
-  observe() {
-    const value$ = __privateGet(this, _store).stateChange$.pipe(rxjs.startWith());
-    return value$;
-  }
-  /**
-   * @important
-   * ISO api react-query
-   */
-  subscribe(listener) {
-    const sub = rxjs.merge(
-      __privateGet(this, _store).added$.pipe(
-        rxjs.tap((mutation) => {
-          listener({
-            type: "added",
-            mutation
-          });
-        })
-      ),
-      __privateGet(this, _store).removed$.pipe(
-        rxjs.tap((mutation) => {
-          listener({
-            type: "removed",
-            mutation
-          });
-        })
-      ),
-      __privateGet(this, _store).stateChange$.pipe(
-        rxjs.tap((mutation) => {
-          listener({
-            type: "updated",
-            action: {
-              ...mutation.state,
-              type: "success"
-            },
-            mutation
-          });
-        })
-      )
-    ).subscribe();
-    return () => {
-      sub.unsubscribe();
-    };
-  }
-  resumePausedMutations() {
-    const pausedMutations = this.findAll({
-      predicate: (mutation) => mutation.state.isPaused
-    });
-    if (!pausedMutations.length) return rxjs.EMPTY;
-    const mutations$ = pausedMutations.map((mutation) => mutation.continue());
-    return rxjs.combineLatest(mutations$);
-  }
-  clear() {
-    this.getAll().forEach((mutation) => {
-      this.remove(mutation);
-    });
-  }
-}
-_store = new WeakMap();
-function getDefaultState(options) {
-  const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
-  const hasData = typeof data !== "undefined";
-  const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
-  return {
-    data,
-    dataUpdateCount: 0,
-    dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
-    error: null,
-    errorUpdateCount: 0,
-    errorUpdatedAt: 0,
-    fetchFailureCount: 0,
-    fetchFailureReason: null,
-    fetchMeta: null,
-    isInvalidated: false,
-    status: hasData ? "success" : "pending",
-    fetchStatus: "idle"
-  };
-}
-const delayUntilFocus = (source) => {
-  return rxjs.defer(() => {
-    if (!focusManager.isFocused()) {
-      return focusManager.focusRegained$.pipe(rxjs.mergeMap(() => source));
-    }
-    return source;
-  });
-};
-const delayOnNetworkMode = (options) => {
-  let attempts = 0;
-  return (source) => {
-    const runWhenOnline$ = onlineManager.backToOnline$.pipe(
-      rxjs.mergeMap(
-        () => rxjs.merge(
-          rxjs.of({ fetchStatus: "fetching" }),
-          source
-        )
-      )
-    );
-    return rxjs.defer(() => {
-      attempts++;
-      if (!onlineManager.isOnline() && options.networkMode === "offlineFirst" && attempts > 1) {
-        return rxjs.merge(
-          rxjs.of({ fetchStatus: "paused" }),
-          runWhenOnline$
-        );
-      }
-      if (!onlineManager.isOnline() && options.networkMode !== "always" && options.networkMode !== "offlineFirst") {
-        return rxjs.merge(
-          rxjs.of({ fetchStatus: "paused" }),
-          runWhenOnline$
-        );
-      }
-      return source;
-    });
-  };
-};
-const completeFnIfNotMoreObservers = (observers$) => (source) => {
-  const hasDataSubject = new rxjs.Subject();
-  const hasDataAndNoObservers$ = hasDataSubject.pipe(
-    rxjs.first(),
-    /**
-     * Since we set hasDataSubject synchronously, we need to wait
-     * for the next tick to make sure observable chain received this data at least
-     */
-    rxjs.delay(1),
-    rxjs.mergeMap(() => observers$.pipe(rxjs.filter((value) => value === 0)))
-  );
-  return source.pipe(
-    rxjs.tap(() => {
-      hasDataSubject.next();
-    }),
-    rxjs.takeUntil(hasDataAndNoObservers$)
-  );
-};
-const executeQuery = (options) => {
-  const defaultFn = async () => await Promise.reject(new Error("No query found"));
-  if (process.env.NODE_ENV !== "production") {
-    if (options.queryFn === skipToken) {
-      console.error(
-        `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'`
-      );
-    }
-  }
-  let fnIsComplete = false;
-  const queryFn = options.queryFn && options.queryFn !== skipToken ? options.queryFn : defaultFn;
-  const abortController = new AbortController();
-  const queryFnContext = {
-    meta: options.meta,
-    queryKey: options.queryKey
-  };
-  const addSignalProperty = (object) => {
-    Object.defineProperty(object, "signal", {
-      enumerable: true,
-      get: () => {
-        options.onSignalConsumed();
-        return abortController.signal;
-      }
-    });
-  };
-  addSignalProperty(queryFnContext);
-  const fn$ = typeof queryFn === "function" ? (
-    // eslint-disable-next-line @typescript-eslint/promise-function-async
-    makeObservable(
-      () => queryFn(queryFnContext)
-    )
-  ) : queryFn;
-  const execution$ = fn$.pipe(
-    completeFnIfNotMoreObservers(options.observers$),
-    rxjs.tap({
-      complete: () => {
-        fnIsComplete = true;
-      }
-    }),
-    rxjs.map(
-      (data) => ({
-        data
-      })
-    ),
-    // takeUntil(hasDataAndNoObservers$),
-    delayOnNetworkMode(options),
-    retryBackoff({
-      ...options,
-      retryAfter: () => rxjs.of(true).pipe(delayUntilFocus),
-      catchError: (attempt, error) => rxjs.of({
-        status: "error",
-        fetchStatus: "idle",
-        fetchFailureCount: attempt,
-        fetchFailureReason: error,
-        error
-      }),
-      caughtError: (attempt, error) => (
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        rxjs.of({
-          fetchFailureCount: attempt,
-          fetchFailureReason: error
-        })
-      )
-    }),
-    rxjs.mergeMap((state) => {
-      if (!("data" in state)) return rxjs.of(state);
-      return rxjs.of({
-        ...state,
-        status: "success",
-        fetchStatus: "idle",
-        fetchFailureCount: 0,
-        fetchFailureReason: null,
-        dataUpdatedAt: (/* @__PURE__ */ new Date()).getTime()
-      }).pipe(
-        /**
-         * Because we don't know yet whether the fn is an observable or a promise we wait
-         * for next tick and check if the function has been complete. This prevent having
-         * two dispatch for promise where we would have extra "fetching" & "idle" dispatch
-         *
-         * @important
-         * Another reason why this delay is necessary is to pass RQ tests. This is because
-         * their flow expect a sequence of results to sometimes happens in a specific
-         * way. If we have non promise function, we have results faster than what RQ expect
-         * due to this library architecture and some variables are impossible to determine
-         * correctly (eg: isFetchedAfterMount). There is nothing wrong, it's just a way to
-         * force any function as promise (or more specifically to return in next tick).
-         *
-         * There is in theory no problem associated to that.
-         */
-        rxjs.delay(1),
-        rxjs.map(
-          (state2) => fnIsComplete ? state2 : { ...state2, fetchStatus: "fetching" }
-        )
-      );
-    }),
-    /**
-     * When the fn complete we can release the fetch status, if it was already released
-     * before shallow compare will not update the state, otherwise it's our chance to catch
-     * the end of observable fn.
-     */
-    rxjs.endWith({ fetchStatus: "idle" }),
-    rxjs.share()
-  );
-  const initialResult$ = rxjs.of({
-    status: "pending",
-    fetchStatus: onlineManager.isOnline() ? "fetching" : "paused"
-  });
-  return {
-    state$: rxjs.merge(
-      initialResult$,
-      execution$
-      // emitOnComplete$
-    ).pipe(rxjs.share()),
-    abortController
-  };
-};
-class CancelledError {
-  constructor(options) {
-    __publicField(this, "revert");
-    __publicField(this, "silent");
-    this.revert = options == null ? void 0 : options.revert;
-    this.silent = options == null ? void 0 : options.silent;
-  }
-}
-const resetStyle = { backgroundColor: "transparent", color: "inherit" };
-function createLogger(env) {
-  const _logger = {
-    namespaces: [
-      {
-        name: "@reactjrx",
-        style: { backgroundColor: "#d02f4e", color: "white" }
-      }
-    ],
-    namespace(name, style) {
-      const logger = createLogger();
-      logger.namespaces.push({
-        name,
-        style: style ?? resetStyle
-      });
-      return logger;
-    },
-    printNamespaces() {
-      return {
-        namespaces: _logger.namespaces.map(({ name }) => `%c ${name} %c`).join(" "),
-        styles: _logger.namespaces.reduce((acc, { style }) => {
-          acc.push(
-            `background-color: ${style.backgroundColor}; color: ${style.color};`
-          );
-          acc.push("background-color: transparent; color: inherit;");
-          return acc;
-        }, [])
-      };
-    },
-    print(method, ...message) {
-      return _logger;
-    },
-    printWithoutNamespace(method, ...message) {
-      return _logger;
-    },
-    log(...message) {
-      return _logger.print("log", ...message);
-    },
-    warn(...message) {
-      return _logger.print("warn", ...message);
-    },
-    error(...message) {
-      return _logger.print("error", ...message);
-    },
-    group(...message) {
-      return _logger.print("group", ...message);
-    },
-    groupEnd() {
-      return _logger;
-    }
-  };
-  return _logger;
-}
-const Logger = createLogger();
-class Query {
-  constructor(config) {
-    __publicField(this, "queryKey");
-    __publicField(this, "queryHash");
-    __publicField(this, "gcTime");
-    __publicField(this, "options");
-    __privateAdd(this, _defaultOptions);
-    __privateAdd(this, _initialState);
-    __publicField(this, "state");
-    // @todo to share with mutation
-    __publicField(this, "executeSubject", new rxjs.Subject());
-    __publicField(this, "cancelSubject", new rxjs.Subject());
-    __publicField(this, "setDataSubject", new rxjs.Subject());
-    __publicField(this, "invalidatedSubject", new rxjs.Subject());
-    __publicField(this, "resetSubject", new rxjs.Subject());
-    __publicField(this, "destroySubject", new rxjs.Subject());
-    __publicField(this, "observersSubject", new rxjs.BehaviorSubject([]));
-    __publicField(this, "abortSignalConsumed", false);
-    __publicField(this, "observerCount$", this.observersSubject.asObservable().pipe(rxjs.map((observers) => observers.length)));
-    __publicField(this, "observers$", this.observersSubject.asObservable());
-    __publicField(this, "state$");
-    __privateSet(this, _defaultOptions, config.defaultOptions);
-    this.options = this.setOptions(config.options);
-    this.queryKey = config.queryKey;
-    this.queryHash = config.queryHash;
-    __privateSet(this, _initialState, config.state ?? getDefaultState(this.options));
-    this.state = __privateGet(this, _initialState);
-    this.gcTime = this.updateGcTime(this.options.gcTime);
-    this.state$ = rxjs.merge(
-      this.resetSubject.pipe(
-        rxjs.map(() => ({ command: "reset", state: __privateGet(this, _initialState) }))
-      ),
-      this.invalidatedSubject.pipe(
-        rxjs.filter(() => !this.state.isInvalidated),
-        rxjs.map(() => ({
-          command: "invalidate",
-          state: {
-            isInvalidated: true
-          }
-        }))
-      ),
-      this.cancelSubject.pipe(
-        rxjs.filter(() => {
-          const isQueryOnError = this.state.error && this.state.status === "error";
-          return !isQueryOnError;
-        }),
-        rxjs.map((options) => ({
-          command: "cancel",
-          state: {
-            status: (options == null ? void 0 : options.revert) ? this.state.status : "error",
-            fetchStatus: "idle",
-            error: new CancelledError(options)
-          }
-        }))
-      ),
-      this.executeSubject.pipe(
-        rxjs.mergeMap(() => {
-          let noMoreObserversActive = false;
-          const cancelFromNewRefetch$ = this.executeSubject.pipe(
-            // should not be needed since the fetch return current promise
-            // in case we don't cancel
-            rxjs.filter((options) => (options == null ? void 0 : options.cancelRefetch) !== false)
-          );
-          const detectNoMoreObserversActive$ = this.observers$.pipe(
-            rxjs.pairwise(),
-            rxjs.tap(([prevObservers, currentObservers]) => {
-              if (currentObservers.length === 0 && prevObservers.length > 0) {
-                noMoreObserversActive = true;
-              } else {
-                noMoreObserversActive = false;
-              }
-            }),
-            rxjs.ignoreElements()
-          );
-          const { state$: functionExecution$, abortController } = executeQuery({
-            ...this.options,
-            observers$: this.observerCount$,
-            queryKey: this.queryKey,
-            retry: (attempt, error) => {
-              const retry = this.options.retry ?? true;
-              if (typeof retry === "function") return retry(attempt, error);
-              if (typeof retry === "boolean") return retry;
-              return attempt < retry;
-            },
-            retryAfterDelay: () => {
-              if (noMoreObserversActive) return false;
-              return true;
-            },
-            onSignalConsumed: () => {
-              this.abortSignalConsumed = true;
-            }
-          });
-          const executionAbortedFromSignal$ = this.observerCount$.pipe(
-            rxjs.filter((count) => count === 0 && this.abortSignalConsumed),
-            rxjs.tap(() => {
-              this.cancelSubject.next({ revert: true });
-            })
-          );
-          const cancelExecution$ = rxjs.merge(
-            this.cancelSubject,
-            cancelFromNewRefetch$,
-            this.resetSubject,
-            executionAbortedFromSignal$
-          ).pipe(
-            rxjs.tap(() => {
-              if (this.abortSignalConsumed) {
-                abortController.abort();
-              }
-            })
-          );
-          return rxjs.merge(functionExecution$, detectNoMoreObserversActive$).pipe(
-            rxjs.map((state) => ({
-              command: "execute",
-              state
-            })),
-            rxjs.takeUntil(cancelExecution$)
-          );
-        })
-      ),
-      this.setDataSubject.pipe(
-        rxjs.map(({ data, options }) => ({
-          command: "setData",
-          state: {
-            status: "success",
-            data,
-            dataUpdatedAt: (options == null ? void 0 : options.updatedAt) !== void 0 ? options.updatedAt : (/* @__PURE__ */ new Date()).getTime()
-          }
-        }))
-      )
-    ).pipe(
-      reduceState({
-        initialState: this.state,
-        getOptions: () => this.options,
-        getState: () => this.state
-      }),
-      rxjs.startWith(__privateGet(this, _initialState)),
-      rxjs.distinctUntilChanged(shallowEqual),
-      rxjs.tap((state) => {
-        this.state = state;
-      }),
-      rxjs.catchError((e) => {
-        Logger.error(e);
-        throw e;
-      }),
-      rxjs.takeUntil(this.destroySubject),
-      rxjs.shareReplay({ bufferSize: 1, refCount: false })
-    );
-  }
-  setOptions(options) {
-    this.options = { ...__privateGet(this, _defaultOptions), ...options };
-    this.updateGcTime(this.options.gcTime);
-    return this.options;
-  }
-  get meta() {
-    return this.options.meta;
-  }
-  get success$() {
-    return this.state$.pipe(
-      rxjs.map(({ data, status }) => ({ data, status })),
-      rxjs.distinctUntilChanged(shallowEqual),
-      rxjs.filter(({ status }) => status === "success")
-    );
-  }
-  get error$() {
-    return this.state$.pipe(
-      rxjs.map(({ error, status }) => ({ error, status })),
-      rxjs.distinctUntilChanged(shallowEqual),
-      rxjs.filter(({ status }) => status === "error")
-    );
-  }
-  get settled$() {
-    return this.state$.pipe(
-      rxjs.map(({ status }) => ({ status })),
-      rxjs.distinctUntilChanged(shallowEqual),
-      rxjs.filter(({ status }) => status === "success" || status === "error")
-    );
-  }
-  observe(observer) {
-    const state$ = this.state$.pipe(
-      rxjs.tap({
-        subscribe: () => {
-          this.observersSubject.next([
-            observer,
-            ...this.observersSubject.getValue()
-          ]);
-        },
-        unsubscribe: () => {
-          this.observersSubject.next(
-            this.observersSubject.getValue().filter((item) => item !== observer)
-          );
-        }
-      })
-    );
-    return state$;
-  }
-  getObserversCount() {
-    return this.observersSubject.getValue().length;
-  }
-  // @todo this can be shared with mutation
-  updateGcTime(newGcTime) {
-    this.gcTime = Math.max(
-      this.gcTime || 0,
-      newGcTime ?? (isServer ? Infinity : 5 * 60 * 1e3)
-    );
-    return this.gcTime;
-  }
-  isActive() {
-    return this.observersSubject.getValue().some((observer) => observer.options.enabled !== false);
-  }
-  isDisabled() {
-    return this.getObserversCount() > 0 && !this.isActive();
-  }
-  isStale() {
-    return this.state.isInvalidated || !this.state.dataUpdatedAt || this.observersSubject.getValue().some((observer) => observer.getCurrentResult().isStale);
-  }
-  isStaleByTime(staleTime = 0) {
-    return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);
-  }
-  async getFetchResultAsPromise() {
-    return await new Promise((resolve, reject) => {
-      this.state$.pipe(takeUntilFinished, rxjs.last()).subscribe({
-        error: reject,
-        next: (data) => {
-          if (data.error) {
-            reject(data.error);
-          } else {
-            resolve(data.data);
-          }
-        }
-      });
-    });
-  }
-  async fetch(options, fetchOptions) {
-    const { cancelRefetch } = fetchOptions ?? {};
-    if (this.state.fetchStatus !== "idle") {
-      const shouldCancelRequest = !!this.state.dataUpdatedAt && cancelRefetch;
-      if (!shouldCancelRequest) {
-        return await this.getFetchResultAsPromise();
-      }
-    }
-    if (options) {
-      this.setOptions(options);
-    }
-    this.executeSubject.next(fetchOptions);
-    return await this.getFetchResultAsPromise();
-  }
-  setData(newData, options) {
-    const data = replaceData(this.state.data, newData, this.options);
-    this.setDataSubject.next({ data, options });
-    return data;
-  }
-  invalidate() {
-    this.invalidatedSubject.next();
-  }
-  async cancel(options) {
-    this.cancelSubject.next(options);
-  }
-  // @todo merge with mutation
-  destroy() {
-    this.destroySubject.next();
-    this.destroySubject.complete();
-    this.executeSubject.complete();
-  }
-  // @todo merge with mutation
-  reset() {
-    this.resetSubject.next();
-  }
-}
-_defaultOptions = new WeakMap();
-_initialState = new WeakMap();
-class QueryCache {
-  // protected mountSubscriptions: Subscription[]
-  constructor(config = {}) {
-    // readonly #queries: QueryStore = new Map<string, Query>()
-    __privateAdd(this, _notifySubject, new rxjs.Subject());
-    __privateAdd(this, _store2, new Store());
-    this.config = config;
-  }
-  mount() {
-  }
-  unmount() {
-  }
-  notify(event) {
-    __privateGet(this, _notifySubject).next(event);
-  }
-  observeIsFetching(filters) {
-    const value$ = __privateGet(this, _store2).stateChange$.pipe(
-      // we force a first result
-      rxjs.startWith(),
-      rxjs.map(() => {
-        const filteredEntities = this.findAll({
-          ...filters,
-          fetchStatus: "fetching"
-        });
-        return filteredEntities.length;
-      }),
-      rxjs.distinctUntilChanged()
-    );
-    return value$;
-  }
-  getAll() {
-    return [...__privateGet(this, _store2).getValues()];
-  }
-  findAll(filters = {}) {
-    const queries = this.getAll();
-    return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries;
-  }
-  build(client, options, state) {
-    const queryKey = options.queryKey ?? [nanoid()];
-    const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options);
-    let query = this.get(queryHash);
-    if (!query) {
-      query = new Query({
-        cache: this,
-        queryKey,
-        queryHash,
-        options: client.defaultQueryOptions(options),
-        state,
-        defaultOptions: client.getQueryDefaults(queryKey)
-      });
-      this.add(query);
-    }
-    return query;
-  }
-  add(query) {
-    if (!__privateGet(this, _store2).find((entity) => entity.queryHash === query.queryHash)) {
-      __privateGet(this, _store2).add(query);
-      const noMoreObservers$ = query.observerCount$.pipe(
-        rxjs.filter((count) => count < 1),
-        rxjs.take(1)
-      );
-      query.success$.subscribe(() => {
-        var _a, _b;
-        (_b = (_a = this.config).onSuccess) == null ? void 0 : _b.call(_a, query.state.data, query);
-      });
-      query.error$.subscribe(() => {
-        var _a, _b;
-        (_b = (_a = this.config).onError) == null ? void 0 : _b.call(_a, query.state.error, query);
-      });
-      query.settled$.subscribe(() => {
-        var _a, _b;
-        (_b = (_a = this.config).onSettled) == null ? void 0 : _b.call(
-          _a,
-          query.state.data,
-          query.state.error,
-          query
-        );
-      });
-      query.state$.pipe(
-        /**
-         * Once a mutation is finished and there are no more observers than us
-         * we start the process of cleaning it up based on gc settings
-         */
-        isQueryFinished,
-        rxjs.switchMap((isFinished) => {
-          return !isFinished ? rxjs.NEVER : noMoreObservers$.pipe(
-            // defaults to 5mn
-            rxjs.switchMap(() => {
-              if (query.gcTime === Infinity) return rxjs.NEVER;
-              setTimeout(rxjs.noop, query.gcTime);
-              return rxjs.timer(query.gcTime);
-            })
-          );
-        }),
-        rxjs.take(1)
-      ).subscribe({
-        complete: () => {
-          this.remove(query);
-        }
-      });
-    }
-  }
-  get(queryHash) {
-    return __privateGet(this, _store2).find((query) => query.queryHash === queryHash);
-  }
-  find(filters) {
-    const defaultedFilters = { exact: true, ...filters };
-    return this.getAll().find(
-      (query) => matchQuery(defaultedFilters, query)
-    );
-  }
-  subscribe(fn) {
-    const sub = rxjs.merge(
-      __privateGet(this, _notifySubject).pipe(rxjs.tap(fn))
-      // this.#store.added$.pipe(
-      //   mergeMap((query) => {
-      //     fn({
-      //       query,
-      //       type: "added"
-      //     })
-      //     return query.observers$.pipe(
-      //       tap((observer) => {
-      //         fn({
-      //           type: "observerAdded",
-      //           observer: observer as unknown as QueryObserver<
-      //             any,
-      //             any,
-      //             any,
-      //             any,
-      //             any
-      //           >,
-      //           query
-      //         })
-      //       })
-      //     )
-      //   })
-      // )
-    ).subscribe();
-    return () => {
-      sub.unsubscribe();
-    };
-  }
-  remove(query) {
-    const queryInMap = __privateGet(this, _store2).find((entity) => entity === query);
-    if (queryInMap) {
-      query.destroy();
-      if (queryInMap === query) {
-        __privateGet(this, _store2).remove(query);
-      }
-    }
-  }
-  clear() {
-  }
-}
-_notifySubject = new WeakMap();
-_store2 = new WeakMap();
-class QueryClient {
-  // #destroy = () => {}
-  constructor({
-    mutationCache,
-    queryCache,
-    defaultOptions
-  } = {}) {
-    __privateAdd(this, _mutationCache);
-    __privateAdd(this, _queryCache);
-    __privateAdd(this, _mutationDefaults, /* @__PURE__ */ new Map());
-    __privateAdd(this, _queryDefaults, /* @__PURE__ */ new Map());
-    __privateAdd(this, _defaultOptions2);
-    __privateSet(this, _mutationCache, mutationCache ?? new MutationCache());
-    __privateSet(this, _queryCache, queryCache ?? new QueryCache());
-    __privateSet(this, _defaultOptions2, defaultOptions ?? {});
-  }
-  mount() {
-  }
-  unmount() {
-  }
-  getMutationCache() {
-    return __privateGet(this, _mutationCache);
-  }
-  getQueryCache() {
-    return __privateGet(this, _queryCache);
-  }
-  defaultMutationOptions(options) {
-    return {
-      ...__privateGet(this, _defaultOptions2).mutations,
-      ...(options == null ? void 0 : options.mutationKey) && this.getMutationDefaults(options.mutationKey),
-      ...options
-    };
-  }
-  defaultQueryOptions(options) {
-    if (options._defaulted) {
-      return options;
-    }
-    const defaultedOptions = {
-      ...__privateGet(this, _defaultOptions2).queries,
-      ...this.getQueryDefaults(options.queryKey),
-      ...options,
-      _defaulted: true
-    };
-    if (!defaultedOptions.queryHash) {
-      defaultedOptions.queryHash = hashQueryKeyByOptions(
-        defaultedOptions.queryKey,
-        defaultedOptions
-      );
-    }
-    if (defaultedOptions.refetchOnReconnect === void 0) {
-      defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always";
-    }
-    if (defaultedOptions.throwOnError === void 0) {
-      defaultedOptions.throwOnError = !!defaultedOptions.suspense;
-    }
-    if (!defaultedOptions.networkMode && defaultedOptions.persister) {
-      defaultedOptions.networkMode = "offlineFirst";
-    }
-    if (defaultedOptions.enabled !== true && defaultedOptions.queryFn === skipToken) {
-      defaultedOptions.enabled = false;
-    }
-    return defaultedOptions;
-  }
-  async fetchQuery(options) {
-    const defaultedOptions = this.defaultQueryOptions(options);
-    if (typeof defaultedOptions.retry === "undefined") {
-      defaultedOptions.retry = false;
-    }
-    const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
-    return query.isStaleByTime(defaultedOptions.staleTime) ? await query.fetch(defaultedOptions) : await Promise.resolve(query.state.data);
-  }
-  async prefetchQuery(options) {
-    await this.fetchQuery(options).then(rxjs.noop).catch(rxjs.noop);
-  }
-  async resetQueries(filters, options) {
-    const queryCache = __privateGet(this, _queryCache);
-    const refetchFilters = {
-      type: "active",
-      ...filters
-    };
-    queryCache.findAll(filters).forEach((query) => {
-      query.reset();
-    });
-    await this.refetchQueries(refetchFilters, options);
-  }
-  async refetchQueries(filters = {}, options) {
-    const fetchOptions = {
-      ...options,
-      cancelRefetch: (options == null ? void 0 : options.cancelRefetch) ?? true
-    };
-    const promises = __privateGet(this, _queryCache).findAll(filters).filter((query) => !query.isDisabled()).map(async (query) => {
-      let promise = query.fetch(void 0, fetchOptions);
-      if (!fetchOptions.throwOnError) {
-        promise = promise.catch(rxjs.noop);
-      }
-      return query.state.fetchStatus === "paused" ? void 0 : await promise;
-    });
-    await Promise.all(promises).then(rxjs.noop);
-  }
-  getQueryData(queryKey) {
-    var _a;
-    const options = this.defaultQueryOptions({ queryKey });
-    return (_a = __privateGet(this, _queryCache).get(options.queryHash)) == null ? void 0 : _a.state.data;
-  }
-  setQueryData(queryKey, updater, options) {
-    const defaultedOptions = this.defaultQueryOptions({ queryKey });
-    const query = __privateGet(this, _queryCache).get(
-      defaultedOptions.queryHash
-    );
-    const prevData = query == null ? void 0 : query.state.data;
-    const data = functionalUpdate(updater, prevData);
-    if (data === void 0) {
-      return void 0;
-    }
-    return __privateGet(this, _queryCache).build(this, defaultedOptions).setData(data, { ...options, manual: true });
-  }
-  getMutationDefaults(mutationKey) {
-    const defaults = [...__privateGet(this, _mutationDefaults).values()];
-    let result = {};
-    defaults.forEach((queryDefault) => {
-      if (matchKey(mutationKey, queryDefault.mutationKey)) {
-        result = { ...result, ...queryDefault.defaultOptions };
-      }
-    });
-    return result;
-  }
-  getQueryState(queryKey) {
-    var _a;
-    return (_a = __privateGet(this, _queryCache).find({ queryKey })) == null ? void 0 : _a.state;
-  }
-  setMutationDefaults(mutationKey, options) {
-    __privateGet(this, _mutationDefaults).set(hashKey(mutationKey), {
-      mutationKey,
-      defaultOptions: options
-    });
-  }
-  setQueryDefaults(queryKey, options) {
-    __privateGet(this, _queryDefaults).set(hashKey(queryKey), {
-      queryKey,
-      defaultOptions: options
-    });
-  }
-  getQueryDefaults(queryKey) {
-    const defaults = [...__privateGet(this, _queryDefaults).values()];
-    let result = {};
-    defaults.forEach((queryDefault) => {
-      if (partialMatchKey(queryKey, queryDefault.queryKey)) {
-        result = { ...result, ...queryDefault.defaultOptions };
-      }
-    });
-    return result;
-  }
-  removeQueries(filters) {
-    const queryCache = __privateGet(this, _queryCache);
-    queryCache.findAll(filters).forEach((query) => {
-      queryCache.remove(query);
-    });
-  }
-  async cancelQueries(filters = {}, cancelOptions = {}) {
-    const defaultedCancelOptions = { revert: true, ...cancelOptions };
-    const promises = __privateGet(this, _queryCache).findAll(filters).map(async (query) => {
-      await query.cancel(defaultedCancelOptions);
-    });
-    await Promise.all(promises).then(rxjs.noop).catch(rxjs.noop);
-  }
-  async invalidateQueries(filters = {}, options = {}) {
-    __privateGet(this, _queryCache).findAll(filters).forEach((query) => {
-      query.invalidate();
-    });
-    if (filters.refetchType === "none") {
-      await Promise.resolve();
-      return;
-    }
-    const refetchFilters = {
-      ...filters,
-      type: filters.refetchType ?? filters.type ?? "active"
-    };
-    await this.refetchQueries(refetchFilters, options);
-  }
-  async resumePausedMutations() {
-    return await rxjs.lastValueFrom(__privateGet(this, _mutationCache).resumePausedMutations());
-  }
-  isFetching(filters) {
-    return __privateGet(this, _queryCache).findAll({ ...filters, fetchStatus: "fetching" }).length;
-  }
-  clear() {
-    __privateGet(this, _queryCache).clear();
-    __privateGet(this, _mutationCache).clear();
-  }
-}
-_mutationCache = new WeakMap();
-_queryCache = new WeakMap();
-_mutationDefaults = new WeakMap();
-_queryDefaults = new WeakMap();
-_defaultOptions2 = new WeakMap();
-exports.Context = Context$1;
-exports.MutationCache = MutationCache;
-exports.QueryCache = QueryCache;
-exports.QueryClient = QueryClient;
+exports.Context = Context;
 exports.QueryClient$ = QueryClient$;
-exports.QueryClientProvider = QueryClientProvider;
 exports.QueryClientProvider$ = QueryClientProvider$;
 exports.SIGNAL_RESET = SIGNAL_RESET;
 exports.arrayEqual = arrayEqual;
@@ -3626,20 +930,17 @@ exports.isServer = isServer;
 exports.retryBackoff = retryBackoff;
 exports.signal = signal;
 exports.useBehaviorSubject = useBehaviorSubject;
+exports.useContactMutation$ = useContactMutation$;
 exports.useEffectOnce = useEffectOnce;
-exports.useForeverQuery = useForeverQuery;
 exports.useLiveBehaviorSubject = useLiveBehaviorSubject;
 exports.useLiveRef = useLiveRef;
 exports.useMount = useMount;
-exports.useMutation = useMutation;
 exports.useMutation$ = useMutation$;
 exports.useObservableCallback = useObservableCallback;
 exports.useObservableState = useObservableState;
 exports.useObserve = useObserve;
 exports.usePersistSignals = usePersistSignals;
-exports.useQuery = useQuery;
 exports.useQuery$ = useQuery$;
-exports.useQueryClient = useQueryClient;
 exports.useQueryClient$ = useQueryClient$;
 exports.useSignal = useSignal;
 exports.useSignalValue = useSignalValue;