reactjrx 1.107.0 → 1.108.3

package/dist/index.cjs

@@ -652,48 +652,141 @@ function isDefined(arg) {
 }
 const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
 const isServer = typeof window === "undefined" || "Deno" in window;
+class QueryClient$ {
+  constructor() {
+    __publicField(this, "queryMap", /* @__PURE__ */ new Map());
+  }
+  getQuery(queryHash) {
+    return this.queryMap.get(queryHash);
+  }
+  setQuery(queryKey, query$, signal2) {
+    const queryHash = reactQuery.hashKey(queryKey);
+    const sharedQuery$ = query$.pipe(
+      /**
+       * abort signal is triggered on:
+       * - manual cancellation from user
+       * - unmounting the component
+       * @see https://tanstack.com/query/latest/docs/framework/react/guides/query-cancellation
+       */
+      rxjs.takeUntil(
+        rxjs.fromEvent(signal2, "abort").pipe(
+          rxjs.tap(() => {
+            debugger;
+          })
+        )
+      ),
+      rxjs.share()
+    );
+    const cacheEntry = {
+      query$: sharedQuery$,
+      signal: signal2,
+      sub: void 0,
+      isCompleted: false,
+      lastData: void 0
+    };
+    this.queryMap.set(queryHash, cacheEntry);
+    const sub = sharedQuery$.subscribe({
+      next: (data) => {
+        const entry = this.queryMap.get(queryHash);
+        if (entry) {
+          entry.lastData = { value: data };
+        }
+      },
+      complete: () => {
+        this.deleteQuery(queryHash);
+      }
+    });
+    cacheEntry.sub = sub;
+    return cacheEntry;
+  }
+  deleteQuery(queryHash) {
+    const entry = this.queryMap.get(queryHash);
+    if (!entry) return;
+    if (entry.sub) {
+      entry.sub.unsubscribe();
+      entry.sub = void 0;
+    }
+    entry.isCompleted = true;
+    this.queryMap.delete(queryHash);
+  }
+  destroy() {
+    this.queryMap.forEach((_, key) => {
+      this.deleteQuery(key);
+    });
+  }
+}
+const Context$1 = React.createContext(void 0);
+const QueryClientProvider$ = React.memo(
+  ({
+    children,
+    client: _client2
+  }) => {
+    const [client] = React.useState(() => _client2 ?? new QueryClient$());
+    React.useEffect(() => {
+      return () => {
+        client.destroy();
+      };
+    }, [client]);
+    return /* @__PURE__ */ jsxRuntime.jsx(Context$1.Provider, { value: client, children });
+  }
+);
+const useQueryClient$ = () => {
+  const client = React.useContext(Context$1);
+  if (!client) {
+    throw new Error(
+      "useReactJrxQueryClient must be used within a ReactJrxQueryProvider"
+    );
+  }
+  return client;
+};
 function useQuery$(options, queryClient) {
-  const sub = React.useRef();
   const _queryClient = reactQuery.useQueryClient(queryClient);
+  const queryClient$ = useQueryClient$();
   const queryFnAsync = (context) => {
-    let isResolved = false;
     return new Promise((resolve, reject) => {
-      let lastData = void 0;
-      if (sub.current) {
-        sub.current.unsubscribe();
-        sub.current = void 0;
-      }
-      const unsub = _queryClient.getQueryCache().subscribe((d) => {
-        var _a;
-        if (d.type === "observerRemoved" && d.query.observers.length === 0) {
-          unsub();
-          _queryClient.cancelQueries({ queryKey: context.queryKey });
-          (_a = sub.current) == null ? void 0 : _a.unsubscribe();
-        }
-      });
-      const source = rxjs.defer(
+      const getSource = () => rxjs.defer(
         () => typeof options.queryFn === "function" ? options.queryFn(context) : options.queryFn
       );
-      sub.current = source.pipe(
-        rxjs.finalize(() => {
-          unsub();
-          isResolved = true;
-        })
+      const queryHash = reactQuery.hashKey(context.queryKey);
+      const queryCacheEntry = queryClient$.getQuery(queryHash) ?? queryClient$.setQuery(
+        context.queryKey,
+        getSource(),
+        context.signal
+      );
+      const query$ = queryCacheEntry.query$;
+      query$.pipe(
+        rxjs.take(1),
+        /**
+         * If several values are emitted during this delay, we will only
+         * keep the last value. This is unfortunate but it's the best we can do
+         * for now.
+         */
+        rxjs.delay(1)
       ).subscribe({
-        next: (data) => {
-          lastData = data;
-          _queryClient == null ? void 0 : _queryClient.setQueryData(context.queryKey, data);
-        },
         error: (error) => {
-          isResolved = true;
-          reject(error);
+          return reject(error);
         },
         complete: () => {
-          if (lastData === void 0)
-            return reject(new Error("Stream completed without any data"));
-          if (isResolved) return;
-          isResolved = true;
-          resolve(lastData);
+          if ((queryCacheEntry == null ? void 0 : queryCacheEntry.lastData) === void 0) {
+            console.log(
+              "cancelled due to stream completing without data",
+              queryCacheEntry == null ? void 0 : queryCacheEntry.lastData
+            );
+            _queryClient.cancelQueries({
+              queryKey: context.queryKey,
+              exact: true
+            });
+            return resolve(void 0);
+          }
+          resolve(queryCacheEntry.lastData.value);
+          if ((queryCacheEntry == null ? void 0 : queryCacheEntry.isCompleted) === false) {
+            setTimeout(() => {
+              _queryClient == null ? void 0 : _queryClient.refetchQueries({
+                queryKey: context.queryKey,
+                exact: true
+              });
+            });
+          }
         }
       });
     });
@@ -747,6 +840,32 @@ function useMutation$(options, queryClient) {
   }, [status, isPending, isError, isSuccess, isIdle, stateSubject]);
   return { ...result, state$: stateSubject.current };
 }
+function useSwitchMutation$(options, queryClient) {
+  const [cancel$, cancel] = useObservableCallback();
+  const {
+    mutate,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    mutateAsync: _removed,
+    ...rest
+  } = useMutation$(
+    {
+      ...options,
+      mutationFn: (variables) => {
+        const source = typeof options.mutationFn === "function" ? options.mutationFn(variables) : options.mutationFn;
+        return source.pipe(rxjs.takeUntil(cancel$), rxjs.defaultIfEmpty(null));
+      }
+    },
+    queryClient
+  );
+  const mutateSwitch = React.useCallback(
+    (variables) => {
+      cancel();
+      mutate(variables);
+    },
+    [mutate, cancel]
+  );
+  return { ...rest, mutate: mutateSwitch };
+}
 function hasObjectPrototype(o) {
   return Object.prototype.toString.call(o) === "[object Object]";
 }
@@ -3493,10 +3612,13 @@ _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.QueryClient$ = QueryClient$;
 exports.QueryClientProvider = QueryClientProvider;
+exports.QueryClientProvider$ = QueryClientProvider$;
 exports.SIGNAL_RESET = SIGNAL_RESET;
 exports.arrayEqual = arrayEqual;
 exports.createLocalStorageAdapter = createLocalStorageAdapter;
@@ -3523,9 +3645,11 @@ exports.usePersistSignals = usePersistSignals;
 exports.useQuery = useQuery;
 exports.useQuery$ = useQuery$;
 exports.useQueryClient = useQueryClient;
+exports.useQueryClient$ = useQueryClient$;
 exports.useSignal = useSignal;
 exports.useSignalValue = useSignalValue;
 exports.useSubject = useSubject;
 exports.useSubscribe = useSubscribe;
 exports.useSubscribeEffect = useSubscribeEffect;
+exports.useSwitchMutation$ = useSwitchMutation$;
 exports.useUnmountObservable = useUnmountObservable;

package/dist/index.d.ts

@@ -16,6 +16,8 @@ export { type SignalPersistenceConfig } from './lib/state/persistance/types';
 export * from './lib/utils';
 export * from './lib/queries/useQuery$';
 export * from './lib/queries/useMutation$';
+export * from './lib/queries/useSwitchMutation$';
+export * from './lib/queries/QueryClientProvider$';
 export * from './lib/deprecated/react/mutations/useMutation';
 export * from './lib/deprecated/react/queries/useQuery';
 export * from './lib/deprecated/react/useQueryClient';

package/dist/index.js

@@ -11,10 +11,10 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 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;
 import * as React from "react";
 import { useRef, useMemo, useCallback, useSyncExternalStore, useEffect, useState, createContext, memo, useContext } from "react";
-import { isObservable, from, of, defer, startWith, identity, distinctUntilChanged, tap, catchError, EMPTY, Subject, BehaviorSubject, skip, first, map, switchMap, zip, share, merge, throttleTime, asyncScheduler, concatMap, scan, throwError, timer, finalize, take, Observable, takeWhile, filter, last, mergeMap as mergeMap$1, takeUntil, shareReplay, ignoreElements, fromEvent, noop as noop$1, pairwise, NEVER, delay, interval, withLatestFrom, retry, iif, isEmpty, concat, toArray, combineLatest, endWith, lastValueFrom } from "rxjs";
+import { isObservable, from, of, defer, startWith, identity, distinctUntilChanged, tap, catchError, EMPTY, Subject, BehaviorSubject, skip, first, map, switchMap, zip, share, merge, throttleTime, asyncScheduler, concatMap, scan, throwError, timer, takeUntil, fromEvent, take, delay, defaultIfEmpty, Observable, takeWhile, filter, last, mergeMap as mergeMap$1, shareReplay, ignoreElements, noop as noop$1, pairwise, NEVER, interval, withLatestFrom, retry, iif, isEmpty, concat, toArray, combineLatest, endWith, lastValueFrom } from "rxjs";
 import { catchError as catchError$1, mergeMap, retryWhen, concatMap as concatMap$1, first as first$1, tap as tap$1 } from "rxjs/operators";
-import { useQueryClient as useQueryClient$1, useQuery as useQuery$1, useMutation as useMutation$1 } from "@tanstack/react-query";
-import { jsxs, jsx } from "react/jsx-runtime";
+import { hashKey as hashKey$1, useQueryClient as useQueryClient$1, useQuery as useQuery$1, useMutation as useMutation$1 } from "@tanstack/react-query";
+import { jsx, jsxs } from "react/jsx-runtime";
 const useLiveRef = (value) => {
   const ref = useRef(value);
   useMemo(() => {
@@ -634,48 +634,141 @@ function isDefined(arg) {
 }
 const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
 const isServer = typeof window === "undefined" || "Deno" in window;
+class QueryClient$ {
+  constructor() {
+    __publicField(this, "queryMap", /* @__PURE__ */ new Map());
+  }
+  getQuery(queryHash) {
+    return this.queryMap.get(queryHash);
+  }
+  setQuery(queryKey, query$, signal2) {
+    const queryHash = hashKey$1(queryKey);
+    const sharedQuery$ = query$.pipe(
+      /**
+       * abort signal is triggered on:
+       * - manual cancellation from user
+       * - unmounting the component
+       * @see https://tanstack.com/query/latest/docs/framework/react/guides/query-cancellation
+       */
+      takeUntil(
+        fromEvent(signal2, "abort").pipe(
+          tap(() => {
+            debugger;
+          })
+        )
+      ),
+      share()
+    );
+    const cacheEntry = {
+      query$: sharedQuery$,
+      signal: signal2,
+      sub: void 0,
+      isCompleted: false,
+      lastData: void 0
+    };
+    this.queryMap.set(queryHash, cacheEntry);
+    const sub = sharedQuery$.subscribe({
+      next: (data) => {
+        const entry = this.queryMap.get(queryHash);
+        if (entry) {
+          entry.lastData = { value: data };
+        }
+      },
+      complete: () => {
+        this.deleteQuery(queryHash);
+      }
+    });
+    cacheEntry.sub = sub;
+    return cacheEntry;
+  }
+  deleteQuery(queryHash) {
+    const entry = this.queryMap.get(queryHash);
+    if (!entry) return;
+    if (entry.sub) {
+      entry.sub.unsubscribe();
+      entry.sub = void 0;
+    }
+    entry.isCompleted = true;
+    this.queryMap.delete(queryHash);
+  }
+  destroy() {
+    this.queryMap.forEach((_, key) => {
+      this.deleteQuery(key);
+    });
+  }
+}
+const Context$1 = createContext(void 0);
+const QueryClientProvider$ = memo(
+  ({
+    children,
+    client: _client2
+  }) => {
+    const [client] = useState(() => _client2 ?? new QueryClient$());
+    useEffect(() => {
+      return () => {
+        client.destroy();
+      };
+    }, [client]);
+    return /* @__PURE__ */ jsx(Context$1.Provider, { value: client, children });
+  }
+);
+const useQueryClient$ = () => {
+  const client = useContext(Context$1);
+  if (!client) {
+    throw new Error(
+      "useReactJrxQueryClient must be used within a ReactJrxQueryProvider"
+    );
+  }
+  return client;
+};
 function useQuery$(options, queryClient) {
-  const sub = useRef();
   const _queryClient = useQueryClient$1(queryClient);
+  const queryClient$ = useQueryClient$();
   const queryFnAsync = (context) => {
-    let isResolved = false;
     return new Promise((resolve, reject) => {
-      let lastData = void 0;
-      if (sub.current) {
-        sub.current.unsubscribe();
-        sub.current = void 0;
-      }
-      const unsub = _queryClient.getQueryCache().subscribe((d) => {
-        var _a;
-        if (d.type === "observerRemoved" && d.query.observers.length === 0) {
-          unsub();
-          _queryClient.cancelQueries({ queryKey: context.queryKey });
-          (_a = sub.current) == null ? void 0 : _a.unsubscribe();
-        }
-      });
-      const source = defer(
+      const getSource = () => defer(
         () => typeof options.queryFn === "function" ? options.queryFn(context) : options.queryFn
       );
-      sub.current = source.pipe(
-        finalize(() => {
-          unsub();
-          isResolved = true;
-        })
+      const queryHash = hashKey$1(context.queryKey);
+      const queryCacheEntry = queryClient$.getQuery(queryHash) ?? queryClient$.setQuery(
+        context.queryKey,
+        getSource(),
+        context.signal
+      );
+      const query$ = queryCacheEntry.query$;
+      query$.pipe(
+        take(1),
+        /**
+         * If several values are emitted during this delay, we will only
+         * keep the last value. This is unfortunate but it's the best we can do
+         * for now.
+         */
+        delay(1)
       ).subscribe({
-        next: (data) => {
-          lastData = data;
-          _queryClient == null ? void 0 : _queryClient.setQueryData(context.queryKey, data);
-        },
         error: (error) => {
-          isResolved = true;
-          reject(error);
+          return reject(error);
         },
         complete: () => {
-          if (lastData === void 0)
-            return reject(new Error("Stream completed without any data"));
-          if (isResolved) return;
-          isResolved = true;
-          resolve(lastData);
+          if ((queryCacheEntry == null ? void 0 : queryCacheEntry.lastData) === void 0) {
+            console.log(
+              "cancelled due to stream completing without data",
+              queryCacheEntry == null ? void 0 : queryCacheEntry.lastData
+            );
+            _queryClient.cancelQueries({
+              queryKey: context.queryKey,
+              exact: true
+            });
+            return resolve(void 0);
+          }
+          resolve(queryCacheEntry.lastData.value);
+          if ((queryCacheEntry == null ? void 0 : queryCacheEntry.isCompleted) === false) {
+            setTimeout(() => {
+              _queryClient == null ? void 0 : _queryClient.refetchQueries({
+                queryKey: context.queryKey,
+                exact: true
+              });
+            });
+          }
         }
       });
     });
@@ -729,6 +822,32 @@ function useMutation$(options, queryClient) {
   }, [status, isPending, isError, isSuccess, isIdle, stateSubject]);
   return { ...result, state$: stateSubject.current };
 }
+function useSwitchMutation$(options, queryClient) {
+  const [cancel$, cancel] = useObservableCallback();
+  const {
+    mutate,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    mutateAsync: _removed,
+    ...rest
+  } = useMutation$(
+    {
+      ...options,
+      mutationFn: (variables) => {
+        const source = typeof options.mutationFn === "function" ? options.mutationFn(variables) : options.mutationFn;
+        return source.pipe(takeUntil(cancel$), defaultIfEmpty(null));
+      }
+    },
+    queryClient
+  );
+  const mutateSwitch = useCallback(
+    (variables) => {
+      cancel();
+      mutate(variables);
+    },
+    [mutate, cancel]
+  );
+  return { ...rest, mutate: mutateSwitch };
+}
 function hasObjectPrototype(o) {
   return Object.prototype.toString.call(o) === "[object Object]";
 }
@@ -3476,10 +3595,13 @@ _mutationDefaults = new WeakMap();
 _queryDefaults = new WeakMap();
 _defaultOptions2 = new WeakMap();
 export {
+  Context$1 as Context,
   MutationCache,
   QueryCache,
   QueryClient,
+  QueryClient$,
   QueryClientProvider,
+  QueryClientProvider$,
   SIGNAL_RESET,
   arrayEqual,
   createLocalStorageAdapter,
@@ -3506,10 +3628,12 @@ export {
   useQuery,
   useQuery$,
   useQueryClient,
+  useQueryClient$,
   useSignal,
   useSignalValue,
   useSubject,
   useSubscribe,
   useSubscribeEffect,
+  useSwitchMutation$,
   useUnmountObservable
 };

package/dist/lib/queries/QueryClientProvider$.d.ts

@@ -0,0 +1,25 @@
+import { QueryKey } from '@tanstack/react-query';
+import { Observable, Subscription } from 'rxjs';
+type CacheEntry = {
+    query$: Observable<unknown>;
+    signal: AbortSignal;
+    sub: Subscription | undefined;
+    isCompleted: boolean;
+    lastData: {
+        value: unknown;
+    } | undefined;
+};
+export declare class QueryClient$ {
+    readonly queryMap: Map<string, CacheEntry>;
+    getQuery(queryHash: string): CacheEntry | undefined;
+    setQuery(queryKey: QueryKey, query$: Observable<unknown>, signal: AbortSignal): CacheEntry;
+    deleteQuery(queryHash: string): void;
+    destroy(): void;
+}
+export declare const Context: import('react').Context<QueryClient$ | undefined>;
+export declare const QueryClientProvider$: import('react').MemoExoticComponent<({ children, client: _client }: {
+    children: React.ReactNode;
+    client?: QueryClient$;
+}) => import("react/jsx-runtime").JSX.Element>;
+export declare const useQueryClient$: () => QueryClient$;
+export {};

package/dist/lib/queries/useMutation$.d.ts

@@ -1,8 +1,9 @@
 import { DefaultError, QueryClient, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
 import { Observable } from 'rxjs';
-export declare function useMutation$<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: Omit<UseMutationOptions<TData, TError, TVariables, TContext>, "mutationFn"> & {
+export type UseMutation$Options<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = Omit<UseMutationOptions<TData, TError, TVariables, TContext>, "mutationFn"> & {
     mutationFn: ((variables: TVariables) => Observable<TData>) | Observable<TData>;
-}, queryClient?: QueryClient): {
+};
+export declare function useMutation$<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: UseMutation$Options<TData, TError, TVariables, TContext>, queryClient?: QueryClient): {
     state$: import('rxjs').BehaviorSubject<Pick<UseMutationResult<TData, TError, TVariables, TContext>, "status" | "isPending" | "isError" | "isSuccess" | "isIdle">>;
     data: undefined;
     variables: undefined;

package/dist/lib/queries/useSwitchMutation$.d.ts

@@ -0,0 +1,71 @@
+import { DefaultError, QueryClient } from '@tanstack/react-query';
+import { UseMutation$Options } from './useMutation$';
+export declare function useSwitchMutation$<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: UseMutation$Options<TData | null, TError, TVariables, TContext>, queryClient?: QueryClient): {
+    mutate: (variables: TVariables) => void;
+    state$: import('rxjs').BehaviorSubject<Pick<import('@tanstack/react-query').UseMutationResult<TData | null, TError, TVariables, TContext>, "status" | "isPending" | "isError" | "isSuccess" | "isIdle">>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: TContext | undefined;
+    failureCount: number;
+    failureReason: TError | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (variables: TVariables) => void;
+    state$: import('rxjs').BehaviorSubject<Pick<import('@tanstack/react-query').UseMutationResult<TData | null, TError, TVariables, TContext>, "status" | "isPending" | "isError" | "isSuccess" | "isIdle">>;
+    data: undefined;
+    variables: TVariables;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: TContext | undefined;
+    failureCount: number;
+    failureReason: TError | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (variables: TVariables) => void;
+    state$: import('rxjs').BehaviorSubject<Pick<import('@tanstack/react-query').UseMutationResult<TData | null, TError, TVariables, TContext>, "status" | "isPending" | "isError" | "isSuccess" | "isIdle">>;
+    data: undefined;
+    error: TError;
+    variables: TVariables;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: TContext | undefined;
+    failureCount: number;
+    failureReason: TError | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (variables: TVariables) => void;
+    state$: import('rxjs').BehaviorSubject<Pick<import('@tanstack/react-query').UseMutationResult<TData | null, TError, TVariables, TContext>, "status" | "isPending" | "isError" | "isSuccess" | "isIdle">>;
+    data: TData | null;
+    error: null;
+    variables: TVariables;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: TContext | undefined;
+    failureCount: number;
+    failureReason: TError | null;
+    isPaused: boolean;
+    submittedAt: number;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reactjrx",
   "private": false,
-  "version": "1.107.0",
+  "version": "1.108.3",
   "type": "module",
   "files": [
     "dist"
@@ -54,7 +54,6 @@
     "eslint-plugin-react-hooks": "^4.6.0",
     "jsdom": "^25.0.0",
     "prettier": "^3.1.0",
-    "react-error-boundary": "^4.0.12",
     "rollup-plugin-node-externals": "^7.0.1",
     "rxjs": "^7.8.0",
     "semantic-release": "^24.1.1",

package/dist/lib/queries/useQuery.test.d.ts

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