reactjrx 1.40.1 → 1.44.1

package/dist/index.cjs

@@ -472,7 +472,9 @@ const mergeResults = (stream$) => stream$.pipe(
       status: "loading"
     }
   ),
-  rxjs.distinctUntilChanged(shallowEqual)
+  rxjs.distinctUntilChanged(
+    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
+  )
 );
 function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
   const queryRef = useLiveRef(query);
@@ -597,27 +599,35 @@ function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
 const Context = react.createContext({
   client: null
 });
+const ClientEffect = ({
+  client
+}) => {
+  react.useEffect(() => {
+    const destroy = client.start();
+    return () => {
+      destroy();
+    };
+  }, [client]);
+  return null;
+};
 const Provider = react.memo(
   ({
     children,
     client
   }) => {
     const value = react.useMemo(() => ({ client }), [client]);
-    react.useEffect(
-      () => () => {
-        client.destroy();
-      },
-      [client]
-    );
-    return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value, children });
+    return /* @__PURE__ */ jsxRuntime.jsxs(Context.Provider, { value, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ClientEffect, { client: value.client }),
+      children
+    ] });
   }
 );
-const useReactJrxProvider = () => {
+const useQueryClient = () => {
   const context = react.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) {
@@ -630,10 +640,16 @@ const createActivityTrigger = (params$) => {
       return shouldRunTrigger !== false ? rxjs.merge(
         rxjs.fromEvent(document, "visibilitychange").pipe(
           rxjs.filter(() => !document.hidden),
-          rxjs.map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+          rxjs.map(() => ({
+            type: "refetch",
+            ignoreStale: shouldRunTrigger === "always"
+          }))
         ),
         rxjs.fromEvent(window, "focus").pipe(
-          rxjs.map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+          rxjs.map(() => ({
+            type: "refetch",
+            ignoreStale: shouldRunTrigger === "always"
+          }))
         )
       ) : rxjs.EMPTY;
     })
@@ -644,7 +660,10 @@ const createNetworkTrigger = (params$) => {
     rxjs.switchMap(({ options: { refetchOnReconnect = true } }) => {
       const shouldRunTrigger = typeof refetchOnReconnect === "function" ? refetchOnReconnect({}) : refetchOnReconnect;
       return shouldRunTrigger !== false ? rxjs.fromEvent(window, "online").pipe(
-        rxjs.map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+        rxjs.map(() => ({
+          type: "refetch",
+          ignoreStale: shouldRunTrigger === "always"
+        }))
       ) : rxjs.EMPTY;
     })
   );
@@ -677,7 +696,7 @@ function useQuery({
   ...options
 }) {
   const internalRefresh$ = useSubject();
-  const { client } = useReactJrxProvider();
+  const client = useQueryClient();
   const params$ = useQueryParams({ queryFn, queryKey, ...options });
   const result = useObserve(
     () => {
@@ -706,18 +725,18 @@ function useQuery({
         newKeyTrigger$,
         newObservableObjectQuery$
       );
-      const refetch$ = rxjs.merge(
-        internalRefresh$.current.pipe(rxjs.map(() => ({ ignoreStale: true }))),
+      const trigger$ = rxjs.merge(
+        internalRefresh$.current,
         rxjs.merge(activityRefetch$, networkRefetch$).pipe(rxjs.throttleTime(500))
       );
       return newQueryTrigger$.pipe(
         rxjs.withLatestFrom(key$),
         rxjs.switchMap(([, key]) => {
-          const { result$ } = client.query$({
+          const { result$ } = client.query({
             key,
             fn$,
             options$,
-            refetch$
+            trigger$
           });
           return result$.pipe(
             rxjs.scan(
@@ -754,7 +773,7 @@ function useQuery({
     [client]
   );
   const refetch = react.useCallback(() => {
-    internalRefresh$.current.next();
+    internalRefresh$.current.next({ type: "refetch", ignoreStale: true });
   }, [client]);
   return { ...result, refetch };
 }
@@ -855,7 +874,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(
@@ -936,7 +955,12 @@ const createQueryStore = () => {
       }));
     };
   };
-  const debugger$ = createDebugger(store$);
+  const start = () => {
+    const debugger$ = createDebugger(store$);
+    return () => {
+      debugger$.unsubscribe();
+    };
+  };
   return {
     set: setValue,
     get: getValue,
@@ -956,15 +980,10 @@ const createQueryStore = () => {
       queryTriggerSubject.next(event);
     },
     size: () => store.size,
-    destroy: () => {
-      debugger$.unsubscribe();
-      queryEventSubject.complete();
-      queryTriggerSubject.complete();
-    }
+    start
   };
 };
 const createQueryTrigger = ({
-  refetch$,
   options$,
   queryStore,
   key
@@ -982,12 +1001,6 @@ const createQueryTrigger = ({
       rxjs.filter((event) => key === event.key),
       rxjs.map(({ trigger: trigger2 }) => trigger2)
     ),
-    refetch$.pipe(
-      rxjs.map((event) => ({
-        ...event,
-        type: "refetch"
-      }))
-    ),
     enabledTrigger$.pipe(
       rxjs.map(() => ({
         type: "enabled",
@@ -1002,12 +1015,18 @@ const deduplicate = (key, queryStore) => (source) => {
   return rxjs.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
@@ -1027,12 +1046,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(
@@ -1156,8 +1173,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 rxjs.of({
         fetchStatus: "idle",
         status: "success",
@@ -1185,6 +1203,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);
 };
@@ -1221,6 +1245,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" }
@@ -1228,15 +1255,10 @@ const createInvalidationClient = ({
     });
   };
   return {
-    invalidateQueries,
-    destroy: () => {
-    }
+    invalidateQueries
   };
 };
-const logger$1 = Logger.namespace("refetch");
-const createRefetchClient = ({
-  queryStore
-}) => {
+const createRefetchClient = (_) => {
   const pipeQueryResult = ({
     options$
   }) => (stream) => {
@@ -1266,28 +1288,11 @@ const createRefetchClient = ({
       )
     );
   };
-  const pipeQueryTrigger = ({
-    key
-  }) => (stream) => {
-    return rxjs.merge(
-      stream.pipe(
-        rxjs.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));
@@ -1453,30 +1458,33 @@ const getInitialQueryEntity = ({ key }) => ({
   queryKey: key,
   runners: []
 });
-const updateStoreWithQuery = ({
+const updateStoreWithNewQuery = ({
   queryStore,
   serializedKey,
   runner$,
+  options$,
   key
 }) => (stream) => stream.pipe(
-  rxjs.map((value) => {
+  rxjs.withLatestFrom(options$),
+  rxjs.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
 }) => {
@@ -1487,7 +1495,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 }));
     }
@@ -1520,47 +1528,107 @@ const createCacheClient = ({
     setQueryData
   };
 };
+const logger = Logger.namespace("refetch");
+const markQueryAsStaleIfRefetch = ({
+  key,
+  serializedKey,
+  queryStore
+}) => (stream) => {
+  return stream.pipe(
+    rxjs.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(
+  rxjs.tap((trigger2) => {
+    if (trigger2.type === "refetch") {
+      queryStore.update(serializedKey, {
+        deduplication_fn: void 0
+      });
+      queryStore.dispatchQueryTrigger({
+        key: serializedKey,
+        trigger: trigger2
+      });
+    }
+  }),
+  rxjs.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 rxjs.Subject(),
+    trigger$: externalTrigger$ = new rxjs.Subject(),
     options$ = new rxjs.BehaviorSubject({})
   }) => {
+    if (!hasCalledStart) {
+      throw new Error("You forgot to start client");
+    }
     const serializedKey = serializeKey(key);
-    const internalRefetch$ = new rxjs.Subject();
     const fn$ = maybeFn$ ?? (maybeFn ? rxjs.of(maybeFn) : rxjs.NEVER);
-    Logger.log("query$()", serializedKey);
+    Logger.log("query$)", serializedKey);
     const runner$ = options$.pipe(rxjs.map((options) => ({ options })));
     let deleteRunner = () => {
     };
-    const initialTrigger$ = rxjs.of({
-      type: "initial",
-      ignoreStale: false
-    });
-    const trigger$ = createQueryTrigger({
-      options$,
-      refetch$: rxjs.merge(refetch$, internalRefetch$),
-      key: serializedKey,
-      queryStore
-    }).pipe(refetchClient.pipeQueryTrigger({ options$, key: serializedKey }));
-    const result$ = rxjs.merge(initialTrigger$, trigger$).pipe(
-      rxjs.withLatestFrom(fn$, options$),
-      rxjs.map(([trigger2, fn, options]) => ({ trigger: trigger2, fn, options })),
-      updateStoreWithQuery({
+    const trigger$ = rxjs.merge(
+      externalTrigger$.pipe(
+        dispatchExternalRefetchToAllQueries({
+          queryStore,
+          serializedKey
+        })
+      ),
+      createQueryTrigger({
+        options$,
+        key: serializedKey,
+        queryStore
+      })
+    ).pipe(rxjs.share());
+    const result$ = rxjs.merge(
+      rxjs.of({
+        type: "initial"
+      }),
+      trigger$
+    ).pipe(
+      updateStoreWithNewQuery({
         key,
         queryStore,
         runner$,
-        serializedKey
+        serializedKey,
+        options$
       }),
       rxjs.map(([value, deleteRunnerFn]) => {
-        deleteRunner = deleteRunnerFn;
-        Logger.log("reactjrx", serializedKey, "query trigger", {
+        if (deleteRunnerFn) {
+          deleteRunner = deleteRunnerFn;
+        }
+        return value;
+      }),
+      markQueryAsStaleIfRefetch({
+        key,
+        options$,
+        queryStore,
+        serializedKey
+      }),
+      rxjs.withLatestFrom(fn$, options$),
+      rxjs.map(([trigger2, fn, options]) => ({ trigger: trigger2, fn, options })),
+      rxjs.map((value) => {
+        Logger.log(serializedKey, "query trigger", {
           trigger: value.trigger,
           options: value.options
         });
@@ -1578,19 +1646,6 @@ const createClient = () => {
           trigger$
         })
       ),
-      // hooks
-      rxjs.switchMap(
-        (result) => rxjs.merge(
-          rxjs.of(result).pipe(
-            refetchClient.pipeQueryResult({
-              key: serializedKey,
-              queryStore,
-              options$,
-              refetch$: internalRefetch$
-            })
-          )
-        )
-      ),
       mergeResults,
       rxjs.withLatestFrom(options$),
       rxjs.takeWhile(([result, options]) => {
@@ -1606,7 +1661,7 @@ const createClient = () => {
       result$
     };
   };
-  const queryListenerSub = createQueryListener(
+  const queryListener$ = createQueryListener(
     queryStore,
     (stream) => stream.pipe(
       rxjs.switchMap((key) => {
@@ -1624,17 +1679,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
   };
 };
 exports.PersistSignals = PersistSignals;
@@ -1654,7 +1717,7 @@ exports.useObserve = useObserve;
 exports.useObserveCallback = useObserveCallback;
 exports.usePersistSignalsContext = usePersistSignalsContext;
 exports.useQuery = useQuery;
-exports.useReactJrxProvider = useReactJrxProvider;
+exports.useQueryClient = useQueryClient;
 exports.useScopeSignals = useScopeSignals;
 exports.useSetSignal = useSetSignal;
 exports.useSignal = useSignal;

package/dist/index.d.ts

@@ -20,4 +20,4 @@ export * from "./lib/queries/react/useAsyncQuery";
 export * from "./lib/queries/react/useQuery";
 export * from "./lib/queries/react/useSubscribeEffect";
 export * from "./lib/queries/client/createClient";
-export { Provider as ReactjrxQueryProvider, useReactJrxProvider } from "./lib/queries/react/Provider";
+export { Provider as ReactjrxQueryProvider, useQueryClient } from "./lib/queries/react/Provider";