reactjrx 1.35.0 → 1.40.1

package/dist/index.cjs

@@ -242,7 +242,6 @@ const PersistSignals = react.memo(
       ).pipe(rxjs.map(() => true));
       return stream.pipe(
         rxjs.tap(() => {
-          console.log("hydration complete");
           if (onReadyRef.current != null)
             onReadyRef.current();
         }),
@@ -411,15 +410,6 @@ function retryBackoff(config) {
     );
   });
 }
-const retryFromOptions = (options) => retryBackoff({
-  initialInterval: 100,
-  ...typeof options.retry === "function" ? {
-    shouldRetry: options.retry
-  } : {
-    maxRetries: options.retry === false ? 0 : options.retry ?? 3
-  }
-});
-const querx = (options) => (source) => source.pipe(retryFromOptions(options));
 const useBehaviorSubject = (state) => {
   const subject = useConstant(() => new rxjs.BehaviorSubject(state));
   const completed = react.useRef(false);
@@ -459,6 +449,31 @@ function shallowEqual(objA, objB) {
   }
   return true;
 }
+const retryOnError = (options) => retryBackoff({
+  initialInterval: 100,
+  ...typeof options.retry === "function" ? {
+    shouldRetry: options.retry
+  } : {
+    maxRetries: options.retry === false ? 0 : options.retry ?? 3
+  }
+});
+const mergeResults = (stream$) => stream$.pipe(
+  rxjs.scan(
+    (acc, current) => {
+      return {
+        ...acc,
+        ...current
+      };
+    },
+    {
+      data: void 0,
+      error: void 0,
+      fetchStatus: "idle",
+      status: "loading"
+    }
+  ),
+  rxjs.distinctUntilChanged(shallowEqual)
+);
 function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
   const queryRef = useLiveRef(query);
   const triggerSubject = useSubject();
@@ -505,7 +520,7 @@ function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
             }),
             rxjs.combineLatest([
               rxjs.defer(() => rxjs.from(queryRef.current(args))).pipe(
-                querx(optionsRef.current),
+                retryOnError(optionsRef.current),
                 rxjs.first(),
                 rxjs.map((data) => ({ data, isError: false })),
                 rxjs.catchError((error) => {
@@ -519,7 +534,6 @@ function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
               isLastMutationCalled
             ]).pipe(
               rxjs.map(([{ data, isError }, isLastMutationCalled2]) => {
-                console.log("success", { data, isLastMutationCalled: isLastMutationCalled2 });
                 if (!isError) {
                   if (optionsRef.current.onSuccess != null)
                     optionsRef.current.onSuccess(data, args);
@@ -580,217 +594,15 @@ function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
   }, []);
   return { ...result, isLoading: result.status === "loading", mutate, reset };
 }
-const useCreateCacheStore = () => {
-  const cacheStore = useBehaviorSubject({});
-  useSubscribe(
-    () => cacheStore.current.pipe(
-      rxjs.skip(1),
-      rxjs.tap(() => {
-        const store = cacheStore.current.getValue();
-        console.log(
-          "[cache] update",
-          Object.keys(store).reduce((acc, key) => {
-            const entry = store[key];
-            if (entry != null) {
-              acc[key] = entry;
-            }
-            acc[key]._debug = {
-              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-              // @ts-expect-error
-              eol: new Date(store[key].date + store[key].ttl)
-            };
-            return acc;
-          }, {})
-        );
-      })
-    ),
-    [cacheStore]
-  );
-  useSubscribe(
-    () => rxjs.interval(1e3).pipe(
-      rxjs.withLatestFrom(cacheStore.current),
-      rxjs.tap(() => {
-        const now = (/* @__PURE__ */ new Date()).getTime();
-        const store = cacheStore.current.getValue();
-        const keys = Object.keys(store);
-        const validKeys = keys.filter((key) => {
-          const value = store[key];
-          if (value != null && value.date + value.ttl > now) {
-            return true;
-          }
-          return false;
-        });
-        if (validKeys.length === keys.length) {
-          return;
-        }
-        const newStore = validKeys.reduce((acc, key) => {
-          const entry = store[key];
-          if (entry != null) {
-            acc[key] = entry;
-          }
-          return acc;
-        }, {});
-        cacheStore.current.next(newStore);
-      })
-    ),
-    [cacheStore]
-  );
-  return cacheStore;
-};
-const useQueryStore = () => {
-  const [store] = react.useState(/* @__PURE__ */ new Map());
-  return store;
-};
-const DEFAULT_STALE = 9999;
-const autoRefetch = (options$ = rxjs.of({})) => (source) => {
-  return source.pipe(
-    rxjs.repeat({
-      delay: () => options$.pipe(
-        rxjs.switchMap(
-          (options) => options.staleTime === Infinity ? rxjs.EMPTY : rxjs.timer(options.staleTime ?? DEFAULT_STALE)
-        )
-      )
-    })
-  );
-};
-const deduplicate = (key, queryStore) => (source) => {
-  if (!key)
-    return source;
-  const sourceFromStore = queryStore == null ? void 0 : queryStore.get(key);
-  const finalSource = sourceFromStore ?? source.pipe(
-    rxjs.finalize(() => {
-      queryStore == null ? void 0 : queryStore.delete(key);
-    }),
-    rxjs.shareReplay({
-      refCount: true,
-      bufferSize: 1
-    })
-  );
-  if (sourceFromStore == null) {
-    queryStore == null ? void 0 : queryStore.set(key, finalSource);
-  }
-  return finalSource;
-};
-const serializeKey = (key) => {
-  if (key.length === 0)
-    return "";
-  return JSON.stringify(key);
-};
-const notifyQueryResult = (options$) => (stream$) => stream$.pipe(
-  rxjs.withLatestFrom(options$),
-  rxjs.map(([result, options]) => {
-    var _a, _b;
-    if (result.error) {
-      (_a = options.onError) == null ? void 0 : _a.call(options, result.error);
-    } else {
-      (_b = options.onSuccess) == null ? void 0 : _b.call(options, result);
-    }
-    return result;
-  })
-);
-const mergeResults = (stream$) => stream$.pipe(
-  rxjs.startWith({ isLoading: false, data: void 0, error: void 0 }),
-  rxjs.pairwise(),
-  rxjs.map(([previous, current]) => ({
-    isLoading: false,
-    data: void 0,
-    error: void 0,
-    ...previous,
-    ...current
-  })),
-  rxjs.distinctUntilChanged(shallowEqual)
-);
-const createClient = () => {
-  const queryStore = /* @__PURE__ */ new Map();
-  const refetch$ = new rxjs.Subject();
-  const query$ = ({
-    key,
-    fn$,
-    options$
-  }) => {
-    const refetch$2 = new rxjs.Subject();
-    const enabled$ = options$.pipe(rxjs.map(({ enabled = true }) => enabled));
-    const disabled$ = enabled$.pipe(
-      rxjs.distinctUntilChanged(),
-      rxjs.filter((enabled) => !enabled)
-    );
-    const triggers = [
-      refetch$2.pipe(rxjs.startWith(null)),
-      enabled$.pipe(
-        rxjs.distinctUntilChanged(),
-        rxjs.filter((enabled) => enabled)
-      )
-    ];
-    const serializedKey = serializeKey(key);
-    const query$2 = rxjs.combineLatest(triggers).pipe(
-      rxjs.tap((params) => {
-        console.log("query$ trigger", { key, params });
-      }),
-      rxjs.withLatestFrom(fn$),
-      rxjs.switchMap(([, query]) => {
-        const deferredQuery = rxjs.defer(() => {
-          const queryOrResponse = typeof query === "function" ? query() : query;
-          return rxjs.from(queryOrResponse);
-        });
-        return rxjs.merge(
-          disabled$.pipe(
-            rxjs.take(1),
-            rxjs.map(() => ({
-              isLoading: false
-            }))
-          ),
-          rxjs.merge(
-            rxjs.of({ isLoading: true, error: void 0 }),
-            deferredQuery.pipe(
-              deduplicate(serializedKey, queryStore),
-              rxjs.map((result) => ({
-                isLoading: false,
-                data: { result },
-                error: void 0
-              })),
-              rxjs.catchError(
-                (error) => rxjs.of({
-                  isLoading: false,
-                  data: void 0,
-                  error
-                })
-              ),
-              notifyQueryResult(options$)
-            )
-          ).pipe(autoRefetch(options$), rxjs.takeUntil(disabled$))
-        );
-      }),
-      mergeResults,
-      rxjs.tap((data) => {
-        console.log("query$ return", data);
-      })
-    );
-    return {
-      query$: query$2,
-      refetch$: refetch$2,
-      enabled$
-    };
-  };
-  return {
-    query$,
-    refetch$,
-    queryStore,
-    destroy: () => {
-    }
-  };
-};
 const Context = react.createContext({
-  cacheStore: {},
-  client: createClient()
+  client: null
 });
 const Provider = react.memo(
   ({
     children,
     client
   }) => {
-    const cacheStore = useCreateCacheStore();
-    const queryStore = useQueryStore();
-    const value = react.useMemo(() => ({ cacheStore, queryStore, client }), [client]);
+    const value = react.useMemo(() => ({ client }), [client]);
     react.useEffect(
       () => () => {
         client.destroy();
@@ -800,91 +612,137 @@ const Provider = react.memo(
     return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value, children });
   }
 );
-const useProvider = () => {
+const useReactJrxProvider = () => {
   const context = react.useContext(Context);
+  if (context === null) {
+    throw new Error("You forgot to register the provider");
+  }
   return { ...context };
 };
 const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
 function isDefined(arg) {
   return arg !== null && arg !== void 0;
 }
-const defaultValue = { data: void 0, isLoading: true, error: void 0 };
-function useQuery(keyOrQuery, queryOrOptionOrNothing, optionsOrNothing) {
-  const query = Array.isArray(keyOrQuery) ? queryOrOptionOrNothing : keyOrQuery;
-  const options = optionsOrNothing ?? (queryOrOptionOrNothing !== query ? queryOrOptionOrNothing : void 0) ?? {};
-  const internalRefresh$ = useSubject();
-  const { client } = useProvider();
-  const key = Array.isArray(keyOrQuery) ? keyOrQuery : void 0;
-  const params$ = useBehaviorSubject({ key, options, query });
+const createActivityTrigger = (params$) => {
+  return params$.pipe(
+    rxjs.switchMap(({ options: { refetchOnWindowFocus = true } }) => {
+      const shouldRunTrigger = typeof refetchOnWindowFocus === "function" ? refetchOnWindowFocus({}) : refetchOnWindowFocus;
+      return shouldRunTrigger !== false ? rxjs.merge(
+        rxjs.fromEvent(document, "visibilitychange").pipe(
+          rxjs.filter(() => !document.hidden),
+          rxjs.map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+        ),
+        rxjs.fromEvent(window, "focus").pipe(
+          rxjs.map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+        )
+      ) : rxjs.EMPTY;
+    })
+  );
+};
+const createNetworkTrigger = (params$) => {
+  return params$.pipe(
+    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.EMPTY;
+    })
+  );
+};
+const useQueryParams = ({
+  queryKey,
+  queryFn,
+  ...options
+}) => {
+  const params$ = useBehaviorSubject({ queryKey, options, queryFn });
   react.useEffect(() => {
     params$.current.next({
-      key,
+      queryKey,
       options,
-      query
+      queryFn
     });
-  }, [key, options, query]);
+  }, [queryKey, options, queryFn]);
+  return params$;
+};
+const defaultValue = {
+  data: void 0,
+  isLoading: true,
+  error: void 0,
+  status: "loading",
+  fetchStatus: "idle"
+};
+function useQuery({
+  queryKey,
+  queryFn,
+  ...options
+}) {
+  const internalRefresh$ = useSubject();
+  const { client } = useReactJrxProvider();
+  const params$ = useQueryParams({ queryFn, queryKey, ...options });
   const result = useObserve(
     () => {
-      const computedDefaultValue = {
-        ...defaultValue,
-        isLoading: params$.current.getValue().options.enabled !== false
-      };
-      const newKeyReceived$ = params$.current.pipe(
-        rxjs.map(({ key: key2 }) => key2 ?? []),
-        rxjs.distinctUntilChanged(arrayEqual)
+      const key$ = params$.current.pipe(rxjs.map(({ queryKey: queryKey2 }) => queryKey2 ?? []));
+      const initialTrigger$ = rxjs.of(null);
+      const newKeyTrigger$ = key$.pipe(
+        rxjs.distinctUntilChanged(arrayEqual),
+        rxjs.skip(1)
       );
+      const isQueryObject = (query) => !!query && typeof query !== "function";
       const newObservableObjectQuery$ = params$.current.pipe(
-        rxjs.map(({ query: query2 }) => query2),
+        rxjs.map(({ queryFn: queryFn2 }) => queryFn2),
+        rxjs.filter(isQueryObject),
         rxjs.distinctUntilChanged(shallowEqual),
-        rxjs.skip(1),
-        rxjs.filter((query2) => !!query2 && typeof query2 !== "function"),
-        rxjs.startWith(params$.current.getValue().query),
-        rxjs.filter(isDefined)
+        isQueryObject(params$.current.getValue().queryFn) ? rxjs.skip(1) : rxjs.identity
       );
       const fn$ = params$.current.pipe(
-        rxjs.map(({ query: query2 }) => query2),
+        rxjs.map(({ queryFn: queryFn2 }) => queryFn2),
         rxjs.filter(isDefined)
       );
       const options$ = params$.current.pipe(rxjs.map(({ options: options2 }) => options2));
-      const triggers$ = rxjs.combineLatest([
-        newKeyReceived$,
+      const activityRefetch$ = createActivityTrigger(params$.current);
+      const networkRefetch$ = createNetworkTrigger(params$.current);
+      const newQueryTrigger$ = rxjs.merge(
+        initialTrigger$,
+        newKeyTrigger$,
         newObservableObjectQuery$
-      ]);
-      return triggers$.pipe(
-        rxjs.switchMap(([key2]) => {
-          const { query$, refetch$ } = client.query$({
-            key: key2,
+      );
+      const refetch$ = rxjs.merge(
+        internalRefresh$.current.pipe(rxjs.map(() => ({ ignoreStale: true }))),
+        rxjs.merge(activityRefetch$, networkRefetch$).pipe(rxjs.throttleTime(500))
+      );
+      return newQueryTrigger$.pipe(
+        rxjs.withLatestFrom(key$),
+        rxjs.switchMap(([, key]) => {
+          const { result$ } = client.query$({
+            key,
             fn$,
-            options$
+            options$,
+            refetch$
           });
-          const subscriptions = [internalRefresh$.current.subscribe(refetch$)];
-          return query$.pipe(
-            rxjs.finalize(() => {
-              subscriptions.forEach((sub) => {
-                sub.unsubscribe();
-              });
-            }),
-            rxjs.startWith(computedDefaultValue),
-            rxjs.pairwise(),
-            rxjs.map(
-              ([
-                { data: previousData, ...restPrevious },
-                { data: currentData, ...restCurrent }
-              ]) => ({
-                ...restPrevious,
-                ...restCurrent,
-                data: currentData && "result" in currentData ? currentData.result : previousData == null ? void 0 : previousData.result
-              })
+          return result$.pipe(
+            rxjs.scan(
+              (previousValue, { data: currentData, ...currentValue }) => ({
+                data: void 0,
+                ...previousValue,
+                ...currentValue,
+                isLoading: currentValue.status === "loading",
+                ...currentData && {
+                  data: currentData.result
+                }
+              }),
+              {}
             )
           );
-        }),
+        })
         /**
          * @important
          * We skip the first result as it is comparable to default passed value.
          * This is assuming all query are async and does not return a result right away.
          * This is a design choice.
          */
-        params$.current.getValue().options.enabled !== false ? rxjs.skip(1) : rxjs.identity
+        // params$.current.getValue().options.enabled !== false
+        //   ? skip(1)
+        //   : identity
       );
     },
     {
@@ -920,6 +778,865 @@ function useSubscribeEffect(source, unsafeOptions, deps = []) {
   );
   useSubscribe(enhancerMakeObservable, deps);
 }
+const serializeObject = (object) => {
+  if (Array.isArray(object)) {
+    return object.reduce((acc, value, index) => {
+      if (index === object.length - 1)
+        return `${acc}${serializeObject(value)}]`;
+      return `${acc}${serializeObject(value)},`;
+    }, "[");
+  }
+  if (object === void 0)
+    return "";
+  return JSON.stringify(object, Object.keys(object).sort());
+};
+const serializeKey = (key) => {
+  if (key.length === 0)
+    return "[]";
+  return serializeObject(key);
+};
+const resetStyle = { backgroundColor: "transparent", color: "inherit" };
+function createLogger(env) {
+  const _logger = {
+    namespaces: [
+      { name: "@reactjrx", style: { backgroundColor: "#d02f4e", color: "white" } }
+    ],
+    namespace(name, style) {
+      const logger2 = createLogger(env);
+      logger2.namespaces.push({
+        name,
+        style: style ?? resetStyle
+      });
+      return logger2;
+    },
+    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) {
+      if (env === "development") {
+        const { namespaces, styles } = _logger.printNamespaces();
+        console[method](namespaces, ...styles, ...message);
+      }
+      return _logger;
+    },
+    printWithoutNamespace(method, ...message) {
+      if (env === "development") {
+        console[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() {
+      if (env === "development") {
+        console.groupEnd();
+      }
+      return _logger;
+    }
+  };
+  return _logger;
+}
+const Logger = createLogger("development");
+const logger$3 = Logger.namespace("store");
+const createDebugger = (store$) => {
+  return store$.pipe(
+    rxjs.map(
+      (value) => [...value.keys()].reduce((acc, key) => {
+        var _a;
+        acc[key] = (_a = value.get(key)) == null ? void 0 : _a.getValue();
+        return acc;
+      }, {})
+    ),
+    rxjs.distinctUntilChanged(shallowEqual)
+  ).subscribe((value) => {
+    logger$3.log("store", "update", value);
+  });
+};
+const createQueryStore = () => {
+  const store = /* @__PURE__ */ new Map();
+  const store$ = new rxjs.BehaviorSubject(store);
+  const queryEventSubject = new rxjs.Subject();
+  const queryTriggerSubject = new rxjs.Subject();
+  const notify = () => {
+    store$.next(store);
+  };
+  const setValue = (key, value) => {
+    store.set(key, new rxjs.BehaviorSubject(value));
+    notify();
+  };
+  const getValue = (serializedKey) => {
+    var _a;
+    return (_a = store.get(serializedKey)) == null ? void 0 : _a.getValue();
+  };
+  const getValue$ = (key) => {
+    return store$.pipe(
+      rxjs.map(() => store.get(key)),
+      rxjs.filter(isDefined),
+      rxjs.map((entry) => entry.getValue()),
+      rxjs.distinctUntilChanged(shallowEqual)
+    );
+  };
+  const updateValue = (key, value) => {
+    const existingObject = store.get(key);
+    if (!existingObject)
+      return;
+    if (typeof value === "function") {
+      existingObject.next({
+        ...existingObject.getValue(),
+        ...value(existingObject.getValue())
+      });
+    } else {
+      existingObject.next({ ...existingObject.getValue(), ...value });
+    }
+    store$.next(store);
+  };
+  const updateMany = (value, predicate = () => true) => {
+    store.forEach((oldValue$) => {
+      const oldValue = oldValue$.getValue();
+      if (predicate(oldValue)) {
+        oldValue$.next({ ...oldValue, ...value });
+      }
+    });
+    store$.next(store);
+  };
+  const deleteValue = (key) => {
+    store.delete(key);
+    store$.next(store);
+  };
+  const addRunner = (key, stream) => {
+    updateValue(key, (old) => ({
+      ...old,
+      runners: [...old.runners, stream]
+    }));
+    return () => {
+      var _a;
+      const newListeners = ((_a = store.get(key)) == null ? void 0 : _a.getValue().runners.filter((reference) => reference !== stream)) ?? [];
+      updateValue(key, (old) => ({
+        ...old,
+        runners: newListeners
+      }));
+    };
+  };
+  const debugger$ = createDebugger(store$);
+  return {
+    set: setValue,
+    get: getValue,
+    get$: getValue$,
+    delete: deleteValue,
+    update: updateValue,
+    keys: () => store.keys(),
+    updateMany,
+    addRunner,
+    store$,
+    queryEvent$: queryEventSubject.asObservable(),
+    dispatchQueryEvent: (event) => {
+      queryEventSubject.next(event);
+    },
+    queryTrigger$: queryTriggerSubject.asObservable(),
+    dispatchQueryTrigger: (event) => {
+      queryTriggerSubject.next(event);
+    },
+    size: () => store.size,
+    destroy: () => {
+      debugger$.unsubscribe();
+      queryEventSubject.complete();
+      queryTriggerSubject.complete();
+    }
+  };
+};
+const createQueryTrigger = ({
+  refetch$,
+  options$,
+  queryStore,
+  key
+}) => {
+  const enabledOption$ = options$.pipe(
+    rxjs.map(({ enabled = true }) => enabled),
+    rxjs.distinctUntilChanged()
+  );
+  const enabledTrigger$ = enabledOption$.pipe(
+    rxjs.skip(1),
+    rxjs.filter((enabled) => enabled)
+  );
+  return rxjs.merge(
+    queryStore.queryTrigger$.pipe(
+      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",
+        ignoreStale: false
+      }))
+    )
+  );
+};
+const deduplicate = (key, queryStore) => (source) => {
+  if (key === serializeKey([]))
+    return source;
+  return rxjs.defer(() => {
+    var _a;
+    const sourceFromStore = (_a = queryStore.get(key)) == null ? void 0 : _a.deduplication_fn;
+    const deleteFromStore = () => {
+      queryStore.update(key, {
+        deduplication_fn: void 0
+      });
+    };
+    const finalSource = sourceFromStore ?? 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
+       * triggered after a new stream arrive which create a concurrency issue.
+       * tap is triggered correctly synchronously and before a new query arrive.
+       */
+      rxjs.tap({
+        error: deleteFromStore,
+        complete: deleteFromStore
+      }),
+      /**
+       * Because tap is not called on unsubscription we still need to handle the case.
+       */
+      rxjs.finalize(deleteFromStore),
+      rxjs.shareReplay({
+        refCount: true,
+        bufferSize: 1
+      })
+    );
+    if (!sourceFromStore) {
+      queryStore.update(key, {
+        deduplication_fn: finalSource
+      });
+    }
+    return finalSource;
+  });
+};
+const notifyQueryResult = (options$) => (stream$) => stream$.pipe(
+  rxjs.withLatestFrom(options$),
+  rxjs.map(([result, options]) => {
+    var _a, _b;
+    if (result.error) {
+      (_a = options.onError) == null ? void 0 : _a.call(options, result.error);
+    } else {
+      (_b = options.onSuccess) == null ? void 0 : _b.call(options, result);
+    }
+    return result;
+  })
+);
+const registerResultInCache = ({
+  queryStore,
+  serializedKey,
+  options
+}) => (stream) => stream.pipe(
+  rxjs.tap(({ data }) => {
+    if (data == null ? void 0 : data.result) {
+      const result = data == null ? void 0 : data.result;
+      queryStore.update(serializedKey, {
+        ...options.cacheTime !== 0 && {
+          cache_fnResult: { result }
+        }
+      });
+    }
+  })
+);
+const createQueryFetch = ({
+  options$,
+  options,
+  fn,
+  queryStore,
+  serializedKey,
+  trigger: trigger2,
+  trigger$
+}) => {
+  const enabledOption$ = options$.pipe(
+    rxjs.map(({ enabled = true }) => enabled),
+    rxjs.distinctUntilChanged()
+  );
+  const disabled$ = enabledOption$.pipe(
+    rxjs.distinctUntilChanged(),
+    rxjs.filter((enabled) => !enabled)
+  );
+  const deferredQuery = rxjs.defer(() => {
+    const queryOrResponse = typeof fn === "function" ? fn() : fn;
+    return rxjs.from(queryOrResponse);
+  });
+  const fnExecution$ = deferredQuery.pipe(
+    retryOnError(options),
+    deduplicate(serializedKey, queryStore),
+    rxjs.tap(() => {
+      queryStore.dispatchQueryEvent({
+        key: serializedKey,
+        type: "fetchSuccess"
+      });
+      queryStore.update(serializedKey, {
+        lastFetchedAt: (/* @__PURE__ */ new Date()).getTime()
+      });
+    }),
+    rxjs.map((result) => ({
+      status: "success",
+      data: { result },
+      error: void 0
+    })),
+    rxjs.endWith({
+      fetchStatus: "idle"
+    }),
+    rxjs.catchError((error) => {
+      queryStore.dispatchQueryEvent({
+        key: serializedKey,
+        type: "fetchError"
+      });
+      return rxjs.of({
+        fetchStatus: "idle",
+        status: "error",
+        data: void 0,
+        error
+      });
+    }),
+    notifyQueryResult(options$),
+    registerResultInCache({ serializedKey, options, queryStore })
+  );
+  const newCache$ = queryStore.queryEvent$.pipe(
+    rxjs.filter(
+      (event) => event.key === serializedKey && event.type === "queryDataSet"
+    ),
+    rxjs.map(() => {
+      var _a, _b;
+      return (_b = (_a = queryStore.get(serializedKey)) == null ? void 0 : _a.cache_fnResult) == null ? void 0 : _b.result;
+    }),
+    rxjs.filter(isDefined),
+    rxjs.map((result) => ({
+      status: "success",
+      data: { result }
+    })),
+    /**
+     * @important
+     * To avoid cache update being returned being the first result is returned.
+     * For example if user set query data inside onSuccess callback, we simulate
+     * a small delay to ensure it happens after.
+     */
+    rxjs.delay(1)
+  );
+  const execution$ = rxjs.merge(
+    disabled$.pipe(
+      rxjs.take(1),
+      rxjs.map(() => ({
+        fetchStatus: "idle"
+      }))
+    ),
+    rxjs.merge(
+      rxjs.of({ fetchStatus: "fetching", error: void 0 }),
+      fnExecution$
+    ).pipe(rxjs.takeUntil(disabled$)),
+    newCache$
+  ).pipe(rxjs.takeUntil(trigger$));
+  const query = queryStore.get(serializedKey);
+  const cacheResult = query == null ? void 0 : query.cache_fnResult;
+  const hasCache = !!cacheResult;
+  if (hasCache) {
+    if (!(query == null ? void 0 : query.isStale) && !trigger2.ignoreStale) {
+      return rxjs.of({
+        fetchStatus: "idle",
+        status: "success",
+        data: { result: cacheResult.result },
+        error: void 0
+      });
+    } else {
+      return rxjs.merge(
+        rxjs.of({
+          fetchStatus: "fetching",
+          status: "success",
+          data: { result: cacheResult.result },
+          error: void 0
+        }),
+        execution$
+      );
+    }
+  }
+  return execution$;
+};
+const compareKeys = (keyA, keyB, { exact = false } = {}) => {
+  if (exact) {
+    return serializeKey(keyA) === serializeKey(keyB);
+  }
+  return keyA.reduce((acc, value, index) => {
+    if (!acc)
+      return false;
+    return serializeObject(value) === serializeObject(keyB[index]);
+  }, true);
+};
+const logger$2 = Logger.namespace("invalidation");
+const createInvalidationClient = ({
+  queryStore
+}) => {
+  const invalidateQueries = ({
+    queryKey,
+    exact = false,
+    predicate
+  } = {}) => {
+    let keysToRefetch = [];
+    if (queryKey) {
+      logger$2.log(`invalidation requested for`, queryKey);
+      queryStore.updateMany({ isStale: true }, (entry) => {
+        const isValid = compareKeys(queryKey, entry.queryKey, { exact });
+        if (isValid) {
+          keysToRefetch.push(serializeKey(entry.queryKey));
+        }
+        return isValid;
+      });
+    } else if (predicate) {
+      queryStore.updateMany({ isStale: true }, (entry) => {
+        const isValid = predicate(entry);
+        if (isValid) {
+          keysToRefetch.push(serializeKey(entry.queryKey));
+        }
+        return isValid;
+      });
+    } else {
+      logger$2.log(`Invalidation requested for all queries`);
+      queryStore.updateMany({ isStale: true });
+      keysToRefetch = Array.from(queryStore.keys());
+    }
+    keysToRefetch.forEach((key) => {
+      queryStore.dispatchQueryTrigger({
+        key,
+        trigger: { ignoreStale: true, type: "refetch" }
+      });
+    });
+  };
+  return {
+    invalidateQueries,
+    destroy: () => {
+    }
+  };
+};
+const logger$1 = Logger.namespace("refetch");
+const createRefetchClient = ({
+  queryStore
+}) => {
+  const pipeQueryResult = ({
+    options$
+  }) => (stream) => {
+    const sharedStream = stream.pipe(rxjs.share());
+    return rxjs.merge(
+      sharedStream,
+      sharedStream.pipe(
+        rxjs.filter(
+          (result) => !!result.data && result.fetchStatus !== "fetching"
+        ),
+        rxjs.distinctUntilChanged((prev, curr) => prev.data === curr.data),
+        rxjs.withLatestFrom(options$),
+        rxjs.map(([, { refetchInterval }]) => refetchInterval),
+        rxjs.filter(isDefined),
+        rxjs.switchMap((refetchInterval) => {
+          if (typeof refetchInterval === "number") {
+            return rxjs.timer(refetchInterval).pipe(
+              rxjs.map(() => ({
+                type: "refetch",
+                ignoreStale: true
+              })),
+              rxjs.switchMap(() => rxjs.EMPTY)
+            );
+          }
+          return rxjs.EMPTY;
+        })
+      )
+    );
+  };
+  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
+            });
+          }
+        })
+      )
+    );
+  };
+  return {
+    pipeQueryResult,
+    pipeQueryTrigger,
+    destroy: () => {
+    }
+  };
+};
+const difference = (a, b) => a.filter((element) => !b.includes(element));
+const createQueryListener = (store, onQuery) => store.store$.pipe(
+  rxjs.map((store2) => [...store2.keys()]),
+  rxjs.startWith([]),
+  rxjs.pairwise(),
+  rxjs.mergeMap(([previousKeys, currentKeys]) => {
+    const newKeys = difference(currentKeys, previousKeys);
+    return rxjs.merge(
+      ...newKeys.map((key) => {
+        const deleted$ = store.store$.pipe(
+          rxjs.map(() => store.get(key)),
+          rxjs.filter((item) => item === void 0)
+        );
+        return rxjs.merge(rxjs.NEVER, rxjs.of(key)).pipe(
+          rxjs.tap(() => {
+          }),
+          onQuery,
+          rxjs.finalize(() => {
+          }),
+          rxjs.takeUntil(deleted$)
+        );
+      })
+    );
+  })
+);
+const mapStoreQueryToRunnerOptions = (stream) => stream.pipe(
+  rxjs.switchMap((entry) => rxjs.combineLatest(entry.runners)),
+  rxjs.map((runnerValues) => runnerValues.map(({ options }) => options))
+);
+const mapOptionsToOption$1 = (stream) => stream.pipe(
+  rxjs.map(
+    (options) => options.reduce(
+      (acc, value) => {
+        return {
+          ...acc,
+          lowestStaleTime: value.staleTime === void 0 ? acc.lowestStaleTime : Math.min(
+            value.staleTime ?? Infinity,
+            acc.lowestStaleTime ?? Infinity
+          )
+        };
+      },
+      { lowestStaleTime: void 0 }
+    )
+  ),
+  rxjs.distinctUntilChanged(shallowEqual)
+);
+const onlyFetchEventDone = (key) => (stream) => stream.pipe(
+  rxjs.filter(
+    (event) => event.key === key && (event.type === "fetchError" || event.type === "fetchSuccess")
+  )
+);
+const markAsStale = ({
+  queryStore
+}) => (stream) => stream.pipe(
+  rxjs.switchMap((key) => {
+    const query$ = queryStore.get$(key);
+    return queryStore.queryEvent$.pipe(
+      onlyFetchEventDone(key),
+      rxjs.switchMap(
+        () => query$.pipe(
+          mapStoreQueryToRunnerOptions,
+          mapOptionsToOption$1,
+          rxjs.tap(({ lowestStaleTime = 0 }) => {
+            var _a;
+            if (lowestStaleTime === 0) {
+              logger$2.log(key, "marked as stale!", {
+                staleTime: lowestStaleTime
+              });
+              queryStore.update(key, { isStale: true });
+            } else if ((_a = queryStore.get(key)) == null ? void 0 : _a.isStale) {
+              logger$2.log(key, "marked non stale", {
+                staleTime: lowestStaleTime
+              });
+              queryStore.update(key, { isStale: false });
+            }
+          }),
+          rxjs.filter(
+            ({ lowestStaleTime }) => lowestStaleTime !== Infinity && lowestStaleTime !== 0
+          ),
+          rxjs.switchMap(({ lowestStaleTime = 0 }) => rxjs.timer(lowestStaleTime)),
+          rxjs.tap(() => {
+            var _a;
+            if (!((_a = queryStore.get(key)) == null ? void 0 : _a.isStale)) {
+              logger$2.log(key, "marked as stale!");
+              queryStore.update(key, { isStale: true });
+            }
+          })
+        )
+      ),
+      rxjs.map(() => key)
+    );
+  })
+);
+const mapOptionsToOption = (stream) => stream.pipe(
+  rxjs.map(
+    (options) => options.reduce(
+      (acc, value) => {
+        return {
+          ...acc,
+          lowestCacheTime: value.cacheTime === void 0 ? acc.lowestCacheTime : Math.min(
+            value.cacheTime ?? Infinity,
+            acc.lowestCacheTime ?? Infinity
+          )
+        };
+      },
+      { lowestCacheTime: void 0 }
+    )
+  ),
+  rxjs.distinctUntilChanged(shallowEqual)
+);
+const onCacheUpdate = (stream) => stream.pipe(
+  rxjs.map((item) => item.cache_fnResult),
+  rxjs.distinctUntilChanged(shallowEqual)
+);
+const invalidateCache = ({
+  queryStore
+}) => (stream) => stream.pipe(
+  rxjs.switchMap((key) => {
+    const query$ = queryStore.get$(key);
+    const invalidateCache$ = query$.pipe(
+      onCacheUpdate,
+      rxjs.switchMap(
+        () => query$.pipe(
+          mapStoreQueryToRunnerOptions,
+          mapOptionsToOption,
+          rxjs.switchMap(
+            ({
+              lowestCacheTime = 5 * 60 * 1e3
+              /* 5mn */
+            }) => rxjs.timer(lowestCacheTime).pipe(
+              rxjs.tap(() => {
+                queryStore.update(key, { cache_fnResult: void 0 });
+              })
+            )
+          )
+        )
+      )
+    );
+    return invalidateCache$.pipe(rxjs.map(() => key));
+  })
+);
+const garbageCache = ({
+  queryStore
+}) => (stream) => stream.pipe(
+  rxjs.switchMap((key) => {
+    const query$ = queryStore.get$(key);
+    return query$.pipe(
+      rxjs.filter((entry) => !entry.cache_fnResult),
+      rxjs.map((entry) => entry.runners.length > 0),
+      rxjs.pairwise(),
+      rxjs.filter(([hadRunners, hasRunners]) => hadRunners && !hasRunners),
+      rxjs.tap(() => {
+        queryStore.delete(key);
+      }),
+      rxjs.map(() => key)
+    );
+  })
+);
+const getInitialQueryEntity = ({ key }) => ({
+  isStale: true,
+  queryKey: key,
+  runners: []
+});
+const updateStoreWithQuery = ({
+  queryStore,
+  serializedKey,
+  runner$,
+  key
+}) => (stream) => stream.pipe(
+  rxjs.map((value) => {
+    if (key.length === 0)
+      return [value, () => {
+      }];
+    if (!queryStore.get(serializedKey)) {
+      queryStore.set(serializedKey, getInitialQueryEntity({ key }));
+    } else {
+      queryStore.update(serializedKey, {
+        queryKey: key,
+        ...value.options.markStale && {
+          isStale: true
+        }
+      });
+    }
+    return [value, queryStore.addRunner(serializedKey, runner$)];
+  })
+);
+const logger = Logger.namespace("cache");
+const createCacheClient = ({
+  queryStore
+}) => {
+  const setQueryData = ({
+    queryKey,
+    updater
+  }) => {
+    const serializedKey = serializeKey(queryKey);
+    if (queryKey.length === 0)
+      return;
+    logger.log("set cache for query", serializeKey);
+    if (!queryStore.get(serializedKey)) {
+      queryStore.set(serializedKey, getInitialQueryEntity({ key: queryKey }));
+    }
+    queryStore.update(serializedKey, (entity) => {
+      var _a;
+      if (typeof updater === "function") {
+        const callableUpdater = updater;
+        return {
+          ...entity,
+          cache_fnResult: {
+            result: callableUpdater(
+              (_a = entity.cache_fnResult) == null ? void 0 : _a.result
+            )
+          }
+        };
+      }
+      return {
+        ...entity,
+        cache_fnResult: {
+          result: updater
+        }
+      };
+    });
+    queryStore.dispatchQueryEvent({
+      key: serializedKey,
+      type: "queryDataSet"
+    });
+  };
+  return {
+    setQueryData
+  };
+};
+const createClient = () => {
+  const queryStore = createQueryStore();
+  const invalidationClient = createInvalidationClient({ queryStore });
+  const cacheClient = createCacheClient({ queryStore });
+  const refetchClient = createRefetchClient({ queryStore });
+  const query$ = ({
+    key,
+    fn$: maybeFn$,
+    fn: maybeFn,
+    refetch$ = new rxjs.Subject(),
+    options$ = new rxjs.BehaviorSubject({})
+  }) => {
+    const serializedKey = serializeKey(key);
+    const internalRefetch$ = new rxjs.Subject();
+    const fn$ = maybeFn$ ?? (maybeFn ? rxjs.of(maybeFn) : rxjs.NEVER);
+    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({
+        key,
+        queryStore,
+        runner$,
+        serializedKey
+      }),
+      rxjs.map(([value, deleteRunnerFn]) => {
+        deleteRunner = deleteRunnerFn;
+        Logger.log("reactjrx", serializedKey, "query trigger", {
+          trigger: value.trigger,
+          options: value.options
+        });
+        return value;
+      }),
+      rxjs.filter(({ options }) => options.enabled !== false),
+      rxjs.mergeMap(
+        ({ fn, options, trigger: trigger2 }) => createQueryFetch({
+          options$,
+          options,
+          fn,
+          queryStore,
+          serializedKey,
+          trigger: trigger2,
+          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]) => {
+        const shouldStop = result.data !== void 0 && options.terminateOnFirstResult;
+        return !shouldStop;
+      }, true),
+      rxjs.map(([result]) => result),
+      rxjs.finalize(() => {
+        deleteRunner();
+      })
+    );
+    return {
+      result$
+    };
+  };
+  const queryListenerSub = createQueryListener(
+    queryStore,
+    (stream) => stream.pipe(
+      rxjs.switchMap((key) => {
+        const key$ = rxjs.of(key);
+        return rxjs.merge(
+          invalidateCache({
+            queryStore
+          })(key$),
+          markAsStale({
+            queryStore
+          })(key$),
+          garbageCache({
+            queryStore
+          })(key$)
+        );
+      })
+    )
+  ).subscribe();
+  return {
+    query$,
+    queryStore,
+    ...invalidationClient,
+    ...cacheClient,
+    ...refetchClient,
+    destroy: () => {
+      queryStore.destroy();
+      queryListenerSub.unsubscribe();
+    }
+  };
+};
 exports.PersistSignals = PersistSignals;
 exports.ReactjrxQueryProvider = Provider;
 exports.SIGNAL_RESET = SIGNAL_RESET;
@@ -937,6 +1654,7 @@ exports.useObserve = useObserve;
 exports.useObserveCallback = useObserveCallback;
 exports.usePersistSignalsContext = usePersistSignalsContext;
 exports.useQuery = useQuery;
+exports.useReactJrxProvider = useReactJrxProvider;
 exports.useScopeSignals = useScopeSignals;
 exports.useSetSignal = useSetSignal;
 exports.useSignal = useSignal;