reactjrx 1.40.1 → 1.44.1

package/dist/index.js

@@ -1,6 +1,6 @@
 import { useRef, useMemo, useCallback, useSyncExternalStore, useEffect, createContext, memo, useContext } from "react";
 import { distinctUntilChanged, tap, finalize, catchError, EMPTY, Subject, identity, BehaviorSubject, of, zip, from, map, merge, throttleTime, switchMap, defer, iif, timer, throwError, scan, take, startWith, combineLatest, first, takeUntil, filter, concatMap as concatMap$1, mergeMap, fromEvent, skip, withLatestFrom, retry, shareReplay, endWith, delay, share, pairwise, NEVER, takeWhile } from "rxjs";
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { retryWhen, concatMap, tap as tap$1 } from "rxjs/operators";
 const useLiveRef = (value) => {
   const ref = useRef(value);
@@ -470,7 +470,9 @@ const mergeResults = (stream$) => stream$.pipe(
       status: "loading"
     }
   ),
-  distinctUntilChanged(shallowEqual)
+  distinctUntilChanged(
+    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
+  )
 );
 function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
   const queryRef = useLiveRef(query);
@@ -595,27 +597,35 @@ function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
 const Context = createContext({
   client: null
 });
+const ClientEffect = ({
+  client
+}) => {
+  useEffect(() => {
+    const destroy = client.start();
+    return () => {
+      destroy();
+    };
+  }, [client]);
+  return null;
+};
 const Provider = memo(
   ({
     children,
     client
   }) => {
     const value = useMemo(() => ({ client }), [client]);
-    useEffect(
-      () => () => {
-        client.destroy();
-      },
-      [client]
-    );
-    return /* @__PURE__ */ jsx(Context.Provider, { value, children });
+    return /* @__PURE__ */ jsxs(Context.Provider, { value, children: [
+      /* @__PURE__ */ jsx(ClientEffect, { client: value.client }),
+      children
+    ] });
   }
 );
-const useReactJrxProvider = () => {
+const useQueryClient = () => {
   const context = useContext(Context);
   if (context === null) {
     throw new Error("You forgot to register the provider");
   }
-  return { ...context };
+  return context.client;
 };
 const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
 function isDefined(arg) {
@@ -628,10 +638,16 @@ const createActivityTrigger = (params$) => {
       return shouldRunTrigger !== false ? merge(
         fromEvent(document, "visibilitychange").pipe(
           filter(() => !document.hidden),
-          map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+          map(() => ({
+            type: "refetch",
+            ignoreStale: shouldRunTrigger === "always"
+          }))
         ),
         fromEvent(window, "focus").pipe(
-          map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+          map(() => ({
+            type: "refetch",
+            ignoreStale: shouldRunTrigger === "always"
+          }))
         )
       ) : EMPTY;
     })
@@ -642,7 +658,10 @@ const createNetworkTrigger = (params$) => {
     switchMap(({ options: { refetchOnReconnect = true } }) => {
       const shouldRunTrigger = typeof refetchOnReconnect === "function" ? refetchOnReconnect({}) : refetchOnReconnect;
       return shouldRunTrigger !== false ? fromEvent(window, "online").pipe(
-        map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+        map(() => ({
+          type: "refetch",
+          ignoreStale: shouldRunTrigger === "always"
+        }))
       ) : EMPTY;
     })
   );
@@ -675,7 +694,7 @@ function useQuery({
   ...options
 }) {
   const internalRefresh$ = useSubject();
-  const { client } = useReactJrxProvider();
+  const client = useQueryClient();
   const params$ = useQueryParams({ queryFn, queryKey, ...options });
   const result = useObserve(
     () => {
@@ -704,18 +723,18 @@ function useQuery({
         newKeyTrigger$,
         newObservableObjectQuery$
       );
-      const refetch$ = merge(
-        internalRefresh$.current.pipe(map(() => ({ ignoreStale: true }))),
+      const trigger$ = merge(
+        internalRefresh$.current,
         merge(activityRefetch$, networkRefetch$).pipe(throttleTime(500))
       );
       return newQueryTrigger$.pipe(
         withLatestFrom(key$),
         switchMap(([, key]) => {
-          const { result$ } = client.query$({
+          const { result$ } = client.query({
             key,
             fn$,
             options$,
-            refetch$
+            trigger$
           });
           return result$.pipe(
             scan(
@@ -752,7 +771,7 @@ function useQuery({
     [client]
   );
   const refetch = useCallback(() => {
-    internalRefresh$.current.next();
+    internalRefresh$.current.next({ type: "refetch", ignoreStale: true });
   }, [client]);
   return { ...result, refetch };
 }
@@ -853,7 +872,7 @@ function createLogger(env) {
   };
   return _logger;
 }
-const Logger = createLogger("development");
+const Logger = createLogger("production");
 const logger$3 = Logger.namespace("store");
 const createDebugger = (store$) => {
   return store$.pipe(
@@ -934,7 +953,12 @@ const createQueryStore = () => {
       }));
     };
   };
-  const debugger$ = createDebugger(store$);
+  const start = () => {
+    const debugger$ = createDebugger(store$);
+    return () => {
+      debugger$.unsubscribe();
+    };
+  };
   return {
     set: setValue,
     get: getValue,
@@ -954,15 +978,10 @@ const createQueryStore = () => {
       queryTriggerSubject.next(event);
     },
     size: () => store.size,
-    destroy: () => {
-      debugger$.unsubscribe();
-      queryEventSubject.complete();
-      queryTriggerSubject.complete();
-    }
+    start
   };
 };
 const createQueryTrigger = ({
-  refetch$,
   options$,
   queryStore,
   key
@@ -980,12 +999,6 @@ const createQueryTrigger = ({
       filter((event) => key === event.key),
       map(({ trigger: trigger2 }) => trigger2)
     ),
-    refetch$.pipe(
-      map((event) => ({
-        ...event,
-        type: "refetch"
-      }))
-    ),
     enabledTrigger$.pipe(
       map(() => ({
         type: "enabled",
@@ -1000,12 +1013,18 @@ const deduplicate = (key, queryStore) => (source) => {
   return defer(() => {
     var _a;
     const sourceFromStore = (_a = queryStore.get(key)) == null ? void 0 : _a.deduplication_fn;
+    if (sourceFromStore)
+      return sourceFromStore;
+    let sourceToDeduplicate;
     const deleteFromStore = () => {
-      queryStore.update(key, {
-        deduplication_fn: void 0
-      });
+      var _a2;
+      if (((_a2 = queryStore.get(key)) == null ? void 0 : _a2.deduplication_fn) === sourceToDeduplicate) {
+        queryStore.update(key, {
+          deduplication_fn: void 0
+        });
+      }
     };
-    const finalSource = sourceFromStore ?? source.pipe(
+    sourceToDeduplicate = source.pipe(
       /**
        * Ideally we would want to remove the query from the store only on finalize,
        * which means whenever the query complete or error. Unfortunately finalize is
@@ -1025,12 +1044,10 @@ const deduplicate = (key, queryStore) => (source) => {
         bufferSize: 1
       })
     );
-    if (!sourceFromStore) {
-      queryStore.update(key, {
-        deduplication_fn: finalSource
-      });
-    }
-    return finalSource;
+    queryStore.update(key, {
+      deduplication_fn: sourceToDeduplicate
+    });
+    return sourceToDeduplicate;
   });
 };
 const notifyQueryResult = (options$) => (stream$) => stream$.pipe(
@@ -1154,8 +1171,9 @@ const createQueryFetch = ({
   const query = queryStore.get(serializedKey);
   const cacheResult = query == null ? void 0 : query.cache_fnResult;
   const hasCache = !!cacheResult;
+  const ignoreStale = trigger2.type === "refetch" && trigger2.ignoreStale;
   if (hasCache) {
-    if (!(query == null ? void 0 : query.isStale) && !trigger2.ignoreStale) {
+    if (!(query == null ? void 0 : query.isStale) && !ignoreStale) {
       return of({
         fetchStatus: "idle",
         status: "success",
@@ -1183,6 +1201,12 @@ const compareKeys = (keyA, keyB, { exact = false } = {}) => {
   return keyA.reduce((acc, value, index) => {
     if (!acc)
       return false;
+    if (value === void 0) {
+      const hasNextItemInLineNotUndefined = keyA.slice(index, keyA.length - 1).some((item) => item !== void 0);
+      if (!hasNextItemInLineNotUndefined) {
+        return true;
+      }
+    }
     return serializeObject(value) === serializeObject(keyB[index]);
   }, true);
 };
@@ -1219,6 +1243,9 @@ const createInvalidationClient = ({
       keysToRefetch = Array.from(queryStore.keys());
     }
     keysToRefetch.forEach((key) => {
+      queryStore.update(key, {
+        deduplication_fn: void 0
+      });
       queryStore.dispatchQueryTrigger({
         key,
         trigger: { ignoreStale: true, type: "refetch" }
@@ -1226,15 +1253,10 @@ const createInvalidationClient = ({
     });
   };
   return {
-    invalidateQueries,
-    destroy: () => {
-    }
+    invalidateQueries
   };
 };
-const logger$1 = Logger.namespace("refetch");
-const createRefetchClient = ({
-  queryStore
-}) => {
+const createRefetchClient = (_) => {
   const pipeQueryResult = ({
     options$
   }) => (stream) => {
@@ -1264,28 +1286,11 @@ const createRefetchClient = ({
       )
     );
   };
-  const pipeQueryTrigger = ({
-    key
-  }) => (stream) => {
-    return merge(
-      stream.pipe(
-        tap(({ ignoreStale }) => {
-          const query = queryStore.get(key);
-          if (query && ignoreStale && !query.isStale) {
-            logger$1.log(key, "marked stale by trigger!");
-            queryStore.update(key, {
-              isStale: true
-            });
-          }
-        })
-      )
-    );
+  const refetchQueries = (_2) => {
   };
   return {
     pipeQueryResult,
-    pipeQueryTrigger,
-    destroy: () => {
-    }
+    refetchQueries
   };
 };
 const difference = (a, b) => a.filter((element) => !b.includes(element));
@@ -1451,30 +1456,33 @@ const getInitialQueryEntity = ({ key }) => ({
   queryKey: key,
   runners: []
 });
-const updateStoreWithQuery = ({
+const updateStoreWithNewQuery = ({
   queryStore,
   serializedKey,
   runner$,
+  options$,
   key
 }) => (stream) => stream.pipe(
-  map((value) => {
+  withLatestFrom(options$),
+  map(([trigger2, options]) => {
     if (key.length === 0)
-      return [value, () => {
-      }];
+      return [trigger2, void 0];
+    if (trigger2.type !== "initial")
+      return [trigger2, void 0];
     if (!queryStore.get(serializedKey)) {
       queryStore.set(serializedKey, getInitialQueryEntity({ key }));
     } else {
       queryStore.update(serializedKey, {
         queryKey: key,
-        ...value.options.markStale && {
+        ...options.markStale && {
           isStale: true
         }
       });
     }
-    return [value, queryStore.addRunner(serializedKey, runner$)];
+    return [trigger2, queryStore.addRunner(serializedKey, runner$)];
   })
 );
-const logger = Logger.namespace("cache");
+const logger$1 = Logger.namespace("cache");
 const createCacheClient = ({
   queryStore
 }) => {
@@ -1485,7 +1493,7 @@ const createCacheClient = ({
     const serializedKey = serializeKey(queryKey);
     if (queryKey.length === 0)
       return;
-    logger.log("set cache for query", serializeKey);
+    logger$1.log("set cache for query", serializeKey);
     if (!queryStore.get(serializedKey)) {
       queryStore.set(serializedKey, getInitialQueryEntity({ key: queryKey }));
     }
@@ -1518,47 +1526,107 @@ const createCacheClient = ({
     setQueryData
   };
 };
+const logger = Logger.namespace("refetch");
+const markQueryAsStaleIfRefetch = ({
+  key,
+  serializedKey,
+  queryStore
+}) => (stream) => {
+  return stream.pipe(
+    tap((trigger2) => {
+      if (trigger2.type !== "refetch")
+        return;
+      const query = queryStore.get(serializedKey);
+      if (query && trigger2.ignoreStale && !query.isStale) {
+        logger.log(key, "marked stale by trigger!");
+        queryStore.update(serializedKey, {
+          isStale: true
+        });
+      }
+    })
+  );
+};
+const dispatchExternalRefetchToAllQueries = ({
+  queryStore,
+  serializedKey
+}) => (stream) => stream.pipe(
+  tap((trigger2) => {
+    if (trigger2.type === "refetch") {
+      queryStore.update(serializedKey, {
+        deduplication_fn: void 0
+      });
+      queryStore.dispatchQueryTrigger({
+        key: serializedKey,
+        trigger: trigger2
+      });
+    }
+  }),
+  filter((trigger2) => trigger2.type !== "refetch")
+);
 const createClient = () => {
   const queryStore = createQueryStore();
   const invalidationClient = createInvalidationClient({ queryStore });
   const cacheClient = createCacheClient({ queryStore });
-  const refetchClient = createRefetchClient({ queryStore });
-  const query$ = ({
+  const refetchClient = createRefetchClient();
+  let hasCalledStart = false;
+  const query = ({
     key,
     fn$: maybeFn$,
     fn: maybeFn,
-    refetch$ = new Subject(),
+    trigger$: externalTrigger$ = new Subject(),
     options$ = new BehaviorSubject({})
   }) => {
+    if (!hasCalledStart) {
+      throw new Error("You forgot to start client");
+    }
     const serializedKey = serializeKey(key);
-    const internalRefetch$ = new Subject();
     const fn$ = maybeFn$ ?? (maybeFn ? of(maybeFn) : NEVER);
-    Logger.log("query$()", serializedKey);
+    Logger.log("query$)", serializedKey);
     const runner$ = options$.pipe(map((options) => ({ options })));
     let deleteRunner = () => {
     };
-    const initialTrigger$ = of({
-      type: "initial",
-      ignoreStale: false
-    });
-    const trigger$ = createQueryTrigger({
-      options$,
-      refetch$: merge(refetch$, internalRefetch$),
-      key: serializedKey,
-      queryStore
-    }).pipe(refetchClient.pipeQueryTrigger({ options$, key: serializedKey }));
-    const result$ = merge(initialTrigger$, trigger$).pipe(
-      withLatestFrom(fn$, options$),
-      map(([trigger2, fn, options]) => ({ trigger: trigger2, fn, options })),
-      updateStoreWithQuery({
+    const trigger$ = merge(
+      externalTrigger$.pipe(
+        dispatchExternalRefetchToAllQueries({
+          queryStore,
+          serializedKey
+        })
+      ),
+      createQueryTrigger({
+        options$,
+        key: serializedKey,
+        queryStore
+      })
+    ).pipe(share());
+    const result$ = merge(
+      of({
+        type: "initial"
+      }),
+      trigger$
+    ).pipe(
+      updateStoreWithNewQuery({
         key,
         queryStore,
         runner$,
-        serializedKey
+        serializedKey,
+        options$
       }),
       map(([value, deleteRunnerFn]) => {
-        deleteRunner = deleteRunnerFn;
-        Logger.log("reactjrx", serializedKey, "query trigger", {
+        if (deleteRunnerFn) {
+          deleteRunner = deleteRunnerFn;
+        }
+        return value;
+      }),
+      markQueryAsStaleIfRefetch({
+        key,
+        options$,
+        queryStore,
+        serializedKey
+      }),
+      withLatestFrom(fn$, options$),
+      map(([trigger2, fn, options]) => ({ trigger: trigger2, fn, options })),
+      map((value) => {
+        Logger.log(serializedKey, "query trigger", {
           trigger: value.trigger,
           options: value.options
         });
@@ -1576,19 +1644,6 @@ const createClient = () => {
           trigger$
         })
       ),
-      // hooks
-      switchMap(
-        (result) => merge(
-          of(result).pipe(
-            refetchClient.pipeQueryResult({
-              key: serializedKey,
-              queryStore,
-              options$,
-              refetch$: internalRefetch$
-            })
-          )
-        )
-      ),
       mergeResults,
       withLatestFrom(options$),
       takeWhile(([result, options]) => {
@@ -1604,7 +1659,7 @@ const createClient = () => {
       result$
     };
   };
-  const queryListenerSub = createQueryListener(
+  const queryListener$ = createQueryListener(
     queryStore,
     (stream) => stream.pipe(
       switchMap((key) => {
@@ -1622,17 +1677,25 @@ const createClient = () => {
         );
       })
     )
-  ).subscribe();
+  );
+  const start = () => {
+    hasCalledStart = true;
+    const queryListenerSub = queryListener$.subscribe();
+    const started = [queryStore.start()];
+    return () => {
+      started.forEach((destroy) => {
+        destroy();
+      });
+      queryListenerSub.unsubscribe();
+    };
+  };
   return {
-    query$,
+    start,
+    query,
     queryStore,
     ...invalidationClient,
     ...cacheClient,
-    ...refetchClient,
-    destroy: () => {
-      queryStore.destroy();
-      queryListenerSub.unsubscribe();
-    }
+    ...refetchClient
   };
 };
 export {
@@ -1653,7 +1716,7 @@ export {
   useObserveCallback,
   usePersistSignalsContext,
   useQuery,
-  useReactJrxProvider,
+  useQueryClient,
   useScopeSignals,
   useSetSignal,
   useSignal,

package/dist/lib/queries/client/createClient.d.ts

@@ -2,7 +2,6 @@ import { type Observable, BehaviorSubject } from "rxjs";
 import { type QueryOptions, type QueryFn, type QueryTrigger, type QueryResult } from "./types";
 import { type QueryKey } from "./keys/types";
 export declare const createClient: () => {
-    destroy: () => void;
     pipeQueryResult: <R extends Partial<QueryResult<T>>, T>({ options$ }: {
         key: string;
         queryStore: {
@@ -22,15 +21,14 @@ export declare const createClient: () => {
             queryTrigger$: Observable<import("./store/createQueryStore").QueryTriggerEvent>;
             dispatchQueryTrigger: (event: import("./store/createQueryStore").QueryTriggerEvent) => void;
             size: () => number;
-            destroy: () => void;
+            start: () => () => void;
         };
         options$: Observable<QueryOptions<T>>;
         refetch$: Observable<QueryTrigger>;
     }) => import("rxjs").MonoTypeOperatorFunction<R>;
-    pipeQueryTrigger: <T_4>({ key }: {
-        key: string;
-        options$: Observable<QueryOptions<T_4>>;
-    }) => import("rxjs").MonoTypeOperatorFunction<QueryTrigger>;
+    refetchQueries: (_: {
+        queryKey: QueryKey;
+    }) => void;
     setQueryData: ({ queryKey, updater }: {
         queryKey: QueryKey;
         updater: unknown;
@@ -40,16 +38,15 @@ export declare const createClient: () => {
         exact?: boolean | undefined;
         predicate?: ((storeObject: import("./store/createQueryStore").StoreObject<unknown>) => boolean) | undefined;
     }) => void;
-    query$: <T_5>({ key, fn$: maybeFn$, fn: maybeFn, refetch$, options$ }: {
+    start: () => () => void;
+    query: <T_4>({ key, fn$: maybeFn$, fn: maybeFn, trigger$: externalTrigger$, options$ }: {
         key: QueryKey;
-        fn?: QueryFn<T_5> | undefined;
-        fn$?: Observable<QueryFn<T_5>> | undefined;
-        refetch$?: Observable<{
-            ignoreStale: boolean;
-        }> | undefined;
-        options$?: Observable<QueryOptions<T_5>> | undefined;
+        fn?: QueryFn<T_4> | undefined;
+        fn$?: Observable<QueryFn<T_4>> | undefined;
+        trigger$?: Observable<QueryTrigger> | undefined;
+        options$?: Observable<QueryOptions<T_4>> | undefined;
     }) => {
-        result$: Observable<QueryResult<T_5>>;
+        result$: Observable<QueryResult<T_4>>;
     };
     queryStore: {
         set: (key: string, value: import("./store/createQueryStore").StoreObject<unknown>) => void;
@@ -68,6 +65,6 @@ export declare const createClient: () => {
         queryTrigger$: Observable<import("./store/createQueryStore").QueryTriggerEvent>;
         dispatchQueryTrigger: (event: import("./store/createQueryStore").QueryTriggerEvent) => void;
         size: () => number;
-        destroy: () => void;
+        start: () => () => void;
     };
 };

package/dist/lib/queries/client/invalidation/invalidationClient.d.ts

@@ -8,5 +8,4 @@ export declare const createInvalidationClient: ({ queryStore }: {
         exact?: boolean | undefined;
         predicate?: ((storeObject: import("../store/createQueryStore").StoreObject<unknown>) => boolean) | undefined;
     }) => void;
-    destroy: () => void;
 };

package/dist/lib/queries/client/refetch/client.d.ts

@@ -1,7 +1,8 @@
 import { type MonoTypeOperatorFunction, type Observable } from "rxjs";
 import { type createQueryStore } from "../store/createQueryStore";
 import { type QueryTrigger, type QueryOptions, type QueryResult } from "../types";
-export declare const createRefetchClient: ({ queryStore }: {
+import { type QueryKey } from "../keys/types";
+export declare const createRefetchClient: (_: {
     queryStore: ReturnType<typeof createQueryStore>;
 }) => {
     pipeQueryResult: <R extends Partial<QueryResult<T>>, T>({ options$ }: {
@@ -10,9 +11,7 @@ export declare const createRefetchClient: ({ queryStore }: {
         options$: Observable<QueryOptions<T>>;
         refetch$: Observable<QueryTrigger>;
     }) => MonoTypeOperatorFunction<R>;
-    pipeQueryTrigger: <T_1>({ key }: {
-        key: string;
-        options$: Observable<QueryOptions<T_1>>;
-    }) => MonoTypeOperatorFunction<QueryTrigger>;
-    destroy: () => void;
+    refetchQueries: (_: {
+        queryKey: QueryKey;
+    }) => void;
 };

package/dist/lib/queries/client/refetch/dispatchExternalRefetchToAllQueries.d.ts

@@ -0,0 +1,3 @@
+import { type MonoTypeOperatorFunction } from "rxjs";
+import { type QueryPipelineParams, type QueryTrigger } from "../types";
+export declare const dispatchExternalRefetchToAllQueries: <R>({ queryStore, serializedKey }: Pick<QueryPipelineParams<R>, "queryStore" | "serializedKey">) => MonoTypeOperatorFunction<QueryTrigger>;

package/dist/lib/queries/client/refetch/logger.d.ts

@@ -0,0 +1,24 @@
+export declare const logger: {
+    namespaces: {
+        name: string;
+        style: {
+            backgroundColor: string;
+            color: string;
+        };
+    }[];
+    namespace(name: string, style?: {
+        backgroundColor: string;
+        color: string;
+    } | undefined): any;
+    printNamespaces(): {
+        namespaces: string;
+        styles: string[];
+    };
+    print(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    printWithoutNamespace(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    log(...message: any): any;
+    warn(...message: any): any;
+    error(...message: any): any;
+    group(...message: any): any;
+    groupEnd(): any;
+};

package/dist/lib/queries/client/refetch/markQueryAsStaleIfRefetch.d.ts

@@ -0,0 +1,3 @@
+import { type MonoTypeOperatorFunction } from "rxjs";
+import { type QueryPipelineParams, type QueryTrigger } from "../types";
+export declare const markQueryAsStaleIfRefetch: <T>({ key, serializedKey, queryStore }: QueryPipelineParams<T>) => MonoTypeOperatorFunction<QueryTrigger>;

package/dist/lib/queries/client/store/createQueryStore.d.ts

@@ -51,5 +51,5 @@ export declare const createQueryStore: () => {
     queryTrigger$: Observable<QueryTriggerEvent>;
     dispatchQueryTrigger: (event: QueryTriggerEvent) => void;
     size: () => number;
-    destroy: () => void;
+    start: () => () => void;
 };