reactjrx 1.32.0 → 1.34.0

package/dist/index.cjs

@@ -459,13 +459,13 @@ function shallowEqual(objA, objB) {
   }
   return true;
 }
-function useMutation(query, mapOperatorOrOptions, options = {}) {
+function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
   const queryRef = useLiveRef(query);
   const triggerSubject = useSubject();
   const resetSubject = useSubject({
     /**
      * @important
-     * Because mutation can still run after unmount, the user might
+     * Because async query can still run after unmount, the user might
      * want to use reset for whatever reason. We will only manually complete
      * this subject whenever the main query hook finalize.
      */
@@ -684,6 +684,33 @@ const autoRefetch = (options = {}) => (source) => {
     })
   );
 };
+function isDefined(arg) {
+  return arg !== null && arg !== void 0;
+}
+const withKeyComparison = (stream) => stream.pipe(
+  rxjs.startWith(void 0),
+  rxjs.pairwise(),
+  rxjs.map(([previous, current]) => {
+    if (current) {
+      if (!previous) {
+        return {
+          ...current,
+          previousKey: void 0,
+          isUsingDifferentKey: true
+        };
+      }
+      const serializedKey = serializeKey(current.key);
+      const serializedPreviousKey = serializeKey(previous.key);
+      return {
+        ...current,
+        previousKey: (previous == null ? void 0 : previous.key) ?? current.key,
+        isUsingDifferentKey: serializedPreviousKey !== serializedKey
+      };
+    }
+    return void 0;
+  }),
+  rxjs.filter(isDefined)
+);
 function useQuery(keyOrQuery, queryOrOptionOrNothing, optionsOrNothing) {
   const query = Array.isArray(keyOrQuery) ? queryOrOptionOrNothing : keyOrQuery;
   const options = optionsOrNothing ?? (queryOrOptionOrNothing !== query ? queryOrOptionOrNothing : void 0) ?? {};
@@ -747,13 +774,15 @@ function useQuery(keyOrQuery, queryOrOptionOrNothing, optionsOrNothing) {
         options: options2,
         query: query2
       })),
+      withKeyComparison,
       rxjs.filter(({ enabled }) => enabled),
-      rxjs.switchMap(({ key: key2, options: options2, query: query2 }) => {
+      rxjs.switchMap(({ key: key2, options: options2, isUsingDifferentKey, query: query2 }) => {
         const serializedKey = serializeKey(key2);
         return rxjs.of(null).pipe(
           rxjs.tap(() => {
             data$.current.next({
               ...data$.current.getValue(),
+              data: isUsingDifferentKey ? void 0 : data$.current.getValue().data,
               error: void 0,
               isLoading: true
             });
@@ -831,8 +860,8 @@ exports.getDelay = getDelay;
 exports.retryBackoff = retryBackoff;
 exports.signal = signal;
 exports.trigger = trigger;
+exports.useAsyncQuery = useAsyncQuery;
 exports.useLiveRef = useLiveRef;
-exports.useMutation = useMutation;
 exports.useObserve = useObserve;
 exports.useObserveCallback = useObserveCallback;
 exports.usePersistSignalsContext = usePersistSignalsContext;

package/dist/index.d.ts

@@ -15,7 +15,7 @@ export * from "./lib/state/persistance/createLocalforageAdapter";
 export * from "./lib/utils/useUnmountObservable";
 export * from "./lib/utils/retryBackoff";
 export * from "./lib/utils/useLiveRef";
-export * from "./lib/queries/useMutation";
+export * from "./lib/queries/useAsyncQuery";
 export * from "./lib/queries/useQuery";
 export * from "./lib/queries/useSubscribeEffect";
 export { Provider as ReactjrxQueryProvider } from "./lib/queries/Provider";

package/dist/index.js

@@ -1,5 +1,5 @@
 import { useRef, useMemo, useCallback, useSyncExternalStore, useEffect, createContext, memo, useContext, useState } from "react";
-import { distinctUntilChanged, tap, finalize, catchError, EMPTY, Subject, identity, BehaviorSubject, of, zip, from, map, merge, throttleTime, switchMap, defer, iif, timer, throwError, take, startWith, combineLatest, first, takeUntil, filter, concatMap as concatMap$1, mergeMap, skip, interval, withLatestFrom, shareReplay, repeat, share, retry } from "rxjs";
+import { distinctUntilChanged, tap, finalize, catchError, EMPTY, Subject, identity, BehaviorSubject, of, zip, from, map, merge, throttleTime, switchMap, defer, iif, timer, throwError, take, startWith, combineLatest, first, takeUntil, filter, concatMap as concatMap$1, mergeMap, skip, interval, withLatestFrom, shareReplay, repeat, pairwise, share, retry } from "rxjs";
 import { jsx } from "react/jsx-runtime";
 import { retryWhen, concatMap, tap as tap$1 } from "rxjs/operators";
 const useLiveRef = (value) => {
@@ -457,13 +457,13 @@ function shallowEqual(objA, objB) {
   }
   return true;
 }
-function useMutation(query, mapOperatorOrOptions, options = {}) {
+function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
   const queryRef = useLiveRef(query);
   const triggerSubject = useSubject();
   const resetSubject = useSubject({
     /**
      * @important
-     * Because mutation can still run after unmount, the user might
+     * Because async query can still run after unmount, the user might
      * want to use reset for whatever reason. We will only manually complete
      * this subject whenever the main query hook finalize.
      */
@@ -682,6 +682,33 @@ const autoRefetch = (options = {}) => (source) => {
     })
   );
 };
+function isDefined(arg) {
+  return arg !== null && arg !== void 0;
+}
+const withKeyComparison = (stream) => stream.pipe(
+  startWith(void 0),
+  pairwise(),
+  map(([previous, current]) => {
+    if (current) {
+      if (!previous) {
+        return {
+          ...current,
+          previousKey: void 0,
+          isUsingDifferentKey: true
+        };
+      }
+      const serializedKey = serializeKey(current.key);
+      const serializedPreviousKey = serializeKey(previous.key);
+      return {
+        ...current,
+        previousKey: (previous == null ? void 0 : previous.key) ?? current.key,
+        isUsingDifferentKey: serializedPreviousKey !== serializedKey
+      };
+    }
+    return void 0;
+  }),
+  filter(isDefined)
+);
 function useQuery(keyOrQuery, queryOrOptionOrNothing, optionsOrNothing) {
   const query = Array.isArray(keyOrQuery) ? queryOrOptionOrNothing : keyOrQuery;
   const options = optionsOrNothing ?? (queryOrOptionOrNothing !== query ? queryOrOptionOrNothing : void 0) ?? {};
@@ -745,13 +772,15 @@ function useQuery(keyOrQuery, queryOrOptionOrNothing, optionsOrNothing) {
         options: options2,
         query: query2
       })),
+      withKeyComparison,
       filter(({ enabled }) => enabled),
-      switchMap(({ key: key2, options: options2, query: query2 }) => {
+      switchMap(({ key: key2, options: options2, isUsingDifferentKey, query: query2 }) => {
         const serializedKey = serializeKey(key2);
         return of(null).pipe(
           tap(() => {
             data$.current.next({
               ...data$.current.getValue(),
+              data: isUsingDifferentKey ? void 0 : data$.current.getValue().data,
               error: void 0,
               isLoading: true
             });
@@ -830,8 +859,8 @@ export {
   retryBackoff,
   signal,
   trigger,
+  useAsyncQuery,
   useLiveRef,
-  useMutation,
   useObserve,
   useObserveCallback,
   usePersistSignalsContext,

package/dist/lib/queries/keys/withKeyComparison.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from "rxjs";
+export declare const withKeyComparison: <T extends {
+    key: any[];
+}>(stream: Observable<T>) => Observable<(T & {
+    previousKey: undefined;
+    isUsingDifferentKey: boolean;
+} extends infer T_1 ? T_1 extends T & {
+    previousKey: undefined;
+    isUsingDifferentKey: boolean;
+} ? T_1 extends null | undefined ? never : T_1 : never : never) | (T & {
+    previousKey: any[];
+    isUsingDifferentKey: boolean;
+} extends infer T_2 ? T_2 extends T & {
+    previousKey: any[];
+    isUsingDifferentKey: boolean;
+} ? T_2 extends null | undefined ? never : T_2 : never : never)>;

package/dist/lib/queries/{useMutation.d.ts → useAsyncQuery.d.ts}

@@ -4,22 +4,22 @@ interface QueryState<R> {
     status: "idle" | "loading" | "error" | "success";
     error: unknown;
 }
-export interface MutationOptions<Result, Params> {
+export interface AsyncQueryOptions<Result, Params> {
     retry?: false | number | ((attempt: number, error: unknown) => boolean);
     /**
-     * Called for every mutation on error.
+     * Called for every async query on error.
      * `merge` mapping will run callback as they happen.
      * Use `concat` if you need to run callbacks in order of calling.
      */
     onError?: (error: unknown, params: Params) => void;
     /**
-     * Called for every mutation on success.
+     * Called for every async query on success.
      * `merge` mapping will run callback as they happen.
      * Use `concat` if you need to run callbacks in order of calling.
      */
     onSuccess?: (data: Result, params: Params) => void;
     /**
-     * When true, any running mutation will be cancelled (when possible) on unmount.
+     * When true, any running async query will be cancelled (when possible) on unmount.
      * You need to handle it yourself for promises if needed.
      * Callbacks will not be called as a result.
      *
@@ -39,19 +39,19 @@ interface Result<A, R> {
     status: "idle" | "loading" | "error" | "success";
     isLoading: boolean;
     /**
-     * If the latest mutation is in a success state, data contains its result.
+     * If the latest async query is in a success state, data contains its result.
      *
      * @important
-     * The value does not automatically reset when a new mutation run. It will be updated
-     * when a new mutation success or error.
+     * The value does not automatically reset when a new async query run. It will be updated
+     * when a new async query success or error.
      */
     data: R | undefined;
     /**
-     * If the latest mutation is in a error state, error contains its error.
+     * If the latest async query is in a error state, error contains its error.
      *
      * @important
-     * The value does not automatically reset when a new mutation run. It will be updated
-     * when a new mutation success or error.
+     * The value does not automatically reset when a new async query run. It will be updated
+     * when a new async query success or error.
      */
     error: unknown | undefined;
     mutate: (args: A) => void;
@@ -63,20 +63,20 @@ interface Result<A, R> {
  * it when specific need arise.
  *
  * `merge`:
- * Run each mutation as they are triggered without any cancellation or queue system.
- * The result is always from the latest mutation triggered, not necessarily
+ * Run each async query as they are triggered without any cancellation or queue system.
+ * The result is always from the latest async query triggered, not necessarily
  * the latest one running.
  *
  * `concat`:
- * Unlike merge, it will trigger each mutation sequentially following
- * a queue system. The result is not necessarily the last triggered mutation
- * but the current running mutation.
+ * Unlike merge, it will trigger each async query sequentially following
+ * a queue system. The result is not necessarily the last triggered async query
+ * but the current running async query.
  *
  * `switch`:
- * Only run the latest mutation triggered and cancel any previously running one.
- * Result correspond to the current running mutation.
+ * Only run the latest async query triggered and cancel any previously running one.
+ * Result correspond to the current running async query.
  */
 type MapOperator = "switch" | "concat" | "merge";
-export declare function useMutation<A = void, R = undefined>(query: (args: A) => Promise<R> | Observable<R>, mapOperatorOrOptions?: MapOperator, options?: MutationOptions<R, A>): Result<A, R>;
-export declare function useMutation<A = void, R = undefined>(query: (args: A) => Promise<R> | Observable<R>, mapOperatorOrOptions?: MutationOptions<R, A>): Result<A, R>;
+export declare function useAsyncQuery<A = void, R = undefined>(query: (args: A) => Promise<R> | Observable<R>, mapOperatorOrOptions?: MapOperator, options?: AsyncQueryOptions<R, A>): Result<A, R>;
+export declare function useAsyncQuery<A = void, R = undefined>(query: (args: A) => Promise<R> | Observable<R>, mapOperatorOrOptions?: AsyncQueryOptions<R, A>): Result<A, R>;
 export {};

package/dist/lib/utils/isDefined.d.ts

@@ -0,0 +1 @@
+export declare function isDefined<T>(arg: T | null | undefined): arg is T extends null | undefined ? never : T;

package/package.json

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