reactjrx 1.34.0 → 1.40.0

package/dist/index.cjs

@@ -147,8 +147,8 @@ function trigger(mapper = rxjs.identity) {
 }
 const SIGNAL_RESET = Symbol("SIGNAL_RESET");
 function signal(options) {
-  const { default: defaultValue } = options ?? {};
-  const subject = new rxjs.BehaviorSubject(defaultValue);
+  const { default: defaultValue2 } = options ?? {};
+  const subject = new rxjs.BehaviorSubject(defaultValue2);
   const setValue = (arg) => {
     if (arg === subject.getValue())
       return;
@@ -160,7 +160,7 @@ function signal(options) {
       return;
     }
     if (arg === SIGNAL_RESET) {
-      subject.next(defaultValue ?? void 0);
+      subject.next(defaultValue2 ?? void 0);
       return;
     }
     subject.next(arg);
@@ -411,15 +411,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 +450,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 +521,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) => {
@@ -546,12 +562,12 @@ function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
         })
       )
     ).pipe(
+      rxjs.filter((state) => !!state && !!Object.keys(state).length),
       /**
        * @important
        * state update optimization
        */
-      rxjs.distinctUntilChanged(shallowEqual),
-      rxjs.filter((state) => !!state && !!Object.keys(state).length)
+      rxjs.distinctUntilChanged(shallowEqual)
     ).subscribe((state) => {
       data$.current.next({
         ...data$.current.getValue(),
@@ -579,255 +595,168 @@ function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
   }, []);
   return { ...result, isLoading: result.status === "loading", mutate, reset };
 }
-const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
-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 Context = react.createContext(void 0);
-const Provider = react.memo(({ children }) => {
-  const cacheStore = useCreateCacheStore();
-  const queryStore = useQueryStore();
-  const value = react.useMemo(() => ({ cacheStore, queryStore }), []);
-  return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value, children });
+const Context = react.createContext({
+  client: null
 });
-const useProvider = () => {
+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 });
+  }
+);
+const useReactJrxProvider = () => {
   const context = react.useContext(Context);
+  if (context === null) {
+    throw new Error("You forgot to register the provider");
+  }
   return { ...context };
 };
-const serializeKey = (key) => {
-  if (key.length === 0)
-    return "";
-  return JSON.stringify(key);
-};
-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
+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 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;
     })
   );
-  if (sourceFromStore == null) {
-    queryStore == null ? void 0 : queryStore.set(key, finalSource);
-  }
-  return finalSource;
 };
-const autoRefetch = (options = {}) => (source) => {
-  if (options.staleTime === Infinity)
-    return source;
-  return source.pipe(
-    rxjs.repeat({
-      delay: options.staleTime ?? 999999
+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;
     })
   );
 };
-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) ?? {};
-  const key = Array.isArray(keyOrQuery) ? keyOrQuery : void 0;
-  const params$ = useBehaviorSubject({ key, options, query });
-  const refetch$ = useSubject();
-  const data$ = useBehaviorSubject({
-    data: void 0,
-    error: void 0,
-    isLoading: true
-  });
-  const { queryStore } = useProvider();
+const useQueryParams = ({
+  queryKey,
+  queryFn,
+  ...options
+}) => {
+  const params$ = useBehaviorSubject({ queryKey, options, queryFn });
   react.useEffect(() => {
     params$.current.next({
-      key,
+      queryKey,
       options,
-      query
+      queryFn
     });
-  }, [key, options, query]);
-  useSubscribe(() => {
-    const options$ = params$.current.pipe(
-      rxjs.map(({ options: options2 }) => options2),
-      rxjs.distinctUntilChanged(shallowEqual)
-    );
-    const newKeyReceived$ = params$.current.pipe(
-      rxjs.map(({ key: key2 }) => key2 ?? []),
-      rxjs.distinctUntilChanged(arrayEqual)
-    );
-    const newQuery$ = params$.current.pipe(
-      rxjs.map(({ query: query2 }) => query2 ?? (() => rxjs.of(void 0)))
-    );
-    const queryAsObservableObjectChanged$ = newQuery$.pipe(
-      rxjs.filter((query2) => typeof query2 !== "function"),
-      rxjs.distinctUntilChanged(shallowEqual)
-    );
-    const enabledOptionChanged$ = options$.pipe(
-      rxjs.map(({ enabled = true }) => enabled),
-      rxjs.distinctUntilChanged(),
-      rxjs.share()
-    );
-    const queryTrigger$ = rxjs.combineLatest([
-      newKeyReceived$,
-      enabledOptionChanged$,
-      queryAsObservableObjectChanged$.pipe(rxjs.startWith(void 0)),
-      refetch$.current.pipe(rxjs.startWith(void 0))
-    ]);
-    const disabled$ = enabledOptionChanged$.pipe(
-      rxjs.filter((enabled) => !enabled),
-      rxjs.tap(() => {
-        data$.current.next({
-          ...data$.current.getValue(),
-          isLoading: false
-        });
-      })
-    );
-    return queryTrigger$.pipe(
-      rxjs.withLatestFrom(options$, newQuery$),
-      rxjs.map(([[key2, enabled], options2, query2]) => ({
-        key: key2,
-        enabled,
-        options: options2,
-        query: query2
-      })),
-      withKeyComparison,
-      rxjs.filter(({ enabled }) => enabled),
-      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
-            });
-          }),
-          rxjs.switchMap(() => {
-            const query$ = rxjs.defer(() => {
-              const queryOrResponse = typeof query2 === "function" ? query2() : query2;
-              return rxjs.from(queryOrResponse);
-            });
-            return query$.pipe(
-              querx(options2),
-              deduplicate(serializedKey, queryStore),
-              // key.length > 0 ? withCache(key) : identity,
-              rxjs.map((response) => [response]),
-              rxjs.catchError((error) => {
-                return rxjs.of([void 0, error]);
-              }),
-              rxjs.tap(([response, error]) => {
-                if (response) {
-                  if (options2.onSuccess != null)
-                    options2.onSuccess(response);
-                }
-                data$.current.next({
-                  ...data$.current.getValue(),
-                  isLoading: false,
-                  error,
-                  data: response
-                });
-              })
-            );
-          }),
-          autoRefetch(options2),
-          rxjs.takeUntil(disabled$)
-        );
-      })
-    );
-  }, []);
+  }, [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(
-    () => data$.current,
-    { defaultValue: data$.current.getValue() },
-    []
+    () => {
+      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(({ queryFn: queryFn2 }) => queryFn2),
+        rxjs.filter(isQueryObject),
+        rxjs.distinctUntilChanged(shallowEqual),
+        isQueryObject(params$.current.getValue().queryFn) ? rxjs.skip(1) : rxjs.identity
+      );
+      const fn$ = params$.current.pipe(
+        rxjs.map(({ queryFn: queryFn2 }) => queryFn2),
+        rxjs.filter(isDefined)
+      );
+      const options$ = params$.current.pipe(rxjs.map(({ options: options2 }) => options2));
+      const activityRefetch$ = createActivityTrigger(params$.current);
+      const networkRefetch$ = createNetworkTrigger(params$.current);
+      const newQueryTrigger$ = rxjs.merge(
+        initialTrigger$,
+        newKeyTrigger$,
+        newObservableObjectQuery$
+      );
+      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$,
+            refetch$
+          });
+          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
+        //   ? skip(1)
+        //   : identity
+      );
+    },
+    {
+      defaultValue: {
+        ...defaultValue,
+        isLoading: params$.current.getValue().options.enabled !== false
+      }
+    },
+    [client]
   );
-  const refetch = react.useCallback((arg) => {
-    refetch$.current.next(arg);
-  }, []);
+  const refetch = react.useCallback(() => {
+    internalRefresh$.current.next();
+  }, [client]);
   return { ...result, refetch };
 }
 function useSubscribeEffect(source, unsafeOptions, deps = []) {
@@ -850,9 +779,877 @@ 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((result) => {
+    queryStore.update(serializedKey, {
+      ...options.cacheTime !== 0 && {
+        cache_fnResult: { result }
+      }
+    });
+  })
+);
+const mapWithComplete = (mapFn) => (stream) => {
+  return stream.pipe(rxjs.map(mapFn({ isComplete: false })));
+};
+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()
+      });
+    }),
+    registerResultInCache({ serializedKey, options, queryStore }),
+    mapWithComplete(({ isComplete }) => (result) => ({
+      status: "success",
+      ...isComplete && {
+        fetchStatus: "idle"
+      },
+      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$)
+  );
+  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(() => {
+            console.log("QUERY", key, "in");
+          }),
+          onQuery,
+          rxjs.finalize(() => {
+            console.log("QUERY", key, "complete");
+          }),
+          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);
+    console.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;
+        console.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.tap((result) => {
+        console.log("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;
+exports.createClient = createClient;
 exports.createLocalforageAdapter = createLocalforageAdapter;
 exports.createSharedStoreAdapter = createSharedStoreAdapter;
 exports.exponentialBackoffDelay = exponentialBackoffDelay;
@@ -866,10 +1663,12 @@ exports.useObserve = useObserve;
 exports.useObserveCallback = useObserveCallback;
 exports.usePersistSignalsContext = usePersistSignalsContext;
 exports.useQuery = useQuery;
+exports.useReactJrxProvider = useReactJrxProvider;
 exports.useScopeSignals = useScopeSignals;
 exports.useSetSignal = useSetSignal;
 exports.useSignal = useSignal;
 exports.useSignalValue = useSignalValue;
+exports.useSubject = useSubject;
 exports.useSubscribe = useSubscribe;
 exports.useSubscribeEffect = useSubscribeEffect;
 exports.useUnmountObservable = useUnmountObservable;