reactjrx 1.112.0 → 1.113.0

package/dist/index.js

@@ -1,457 +1,321 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { useRef, useMemo, useCallback, useSyncExternalStore, useEffect, useState, createContext, memo, useContext } from "react";
-import { isObservable, from, of, defer, startWith, identity, distinctUntilChanged, tap, catchError, EMPTY, Subject, BehaviorSubject, retry, skip, first, map, switchMap, zip, share, merge, throttleTime, asyncScheduler, concatMap, scan, throwError, timer, takeUntil, fromEvent, take, delay, defaultIfEmpty, filter, noop } from "rxjs";
-import { catchError as catchError$1, mergeMap, retryWhen, concatMap as concatMap$1, first as first$1, tap as tap$1 } from "rxjs/operators";
-import { hashKey, useQueryClient, useQuery, useMutation } from "@tanstack/react-query";
-import { jsx } from "react/jsx-runtime";
-const useLiveRef = (value) => {
-  const ref = useRef(value);
-  useMemo(() => {
-    ref.current = value;
-  }, [value]);
-  return ref;
+var ce = Object.defineProperty;
+var ae = (e, t, r) => t in e ? ce(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var D = (e, t, r) => ae(e, typeof t != "symbol" ? t + "" : t, r);
+import { useRef as I, useMemo as oe, useCallback as v, useSyncExternalStore as ie, useEffect as S, useState as U, createContext as le, memo as fe, useContext as ye } from "react";
+import { isObservable as _, from as E, of as p, defer as P, startWith as de, identity as Q, distinctUntilChanged as J, tap as G, catchError as M, EMPTY as N, Subject as H, BehaviorSubject as F, retry as me, skip as pe, first as W, map as C, switchMap as $, zip as be, share as Y, merge as x, throttleTime as ve, asyncScheduler as ge, concatMap as he, scan as Se, throwError as O, timer as Ve, takeUntil as X, fromEvent as Ie, take as Z, delay as we, defaultIfEmpty as Ee, filter as $e, noop as K } from "rxjs";
+import { catchError as z, mergeMap as R, retryWhen as Me, concatMap as Fe, first as xe, tap as qe } from "rxjs/operators";
+import { hashKey as B, useQueryClient as ee, useQuery as Oe, useMutation as Re } from "@tanstack/react-query";
+import { jsx as Ae } from "react/jsx-runtime";
+const h = (e) => {
+  const t = I(e);
+  return oe(() => {
+    t.current = e;
+  }, [e]), t;
 };
-function isPromiseLike(value) {
-  return value instanceof Promise || value && typeof value === "object" && "then" in value && typeof value.then === "function" && "catch" in value && value.catch === "function";
+function T(e) {
+  return e instanceof Promise || e && typeof e == "object" && "then" in e && typeof e.then == "function" && "catch" in e && e.catch === "function";
 }
-function makeObservable(something) {
-  if (isObservable(something)) return () => something;
-  if (isPromiseLike(something)) return () => from(something);
-  if (typeof something !== "function") return () => of(something);
-  const somethingAsFunction = something;
-  return (params) => defer(() => {
-    const result = somethingAsFunction(params);
-    if (isPromiseLike(result)) {
-      return from(result);
-    }
-    if (isObservable(result)) {
-      return result;
-    }
-    return of(result);
+function k(e) {
+  if (_(e)) return () => e;
+  if (T(e)) return () => E(e);
+  if (typeof e != "function") return () => p(e);
+  const t = e;
+  return (r) => P(() => {
+    const n = t(r);
+    return T(n) ? E(n) : _(n) ? n : p(n);
   });
 }
-function useObserve(source$, optionsOrDeps, maybeDeps) {
-  const options = optionsOrDeps != null && !Array.isArray(optionsOrDeps) ? optionsOrDeps : {
+function te(e, t, r) {
+  const n = t != null && !Array.isArray(t) ? t : {
     defaultValue: void 0,
-    unsubscribeOnUnmount: true,
+    unsubscribeOnUnmount: !0,
     compareFn: void 0
-  };
-  const deps = !maybeDeps && Array.isArray(optionsOrDeps) ? optionsOrDeps : typeof source$ === "function" ? maybeDeps ?? [] : [source$];
-  const valueRef = useRef(
-    "getValue" in source$ && typeof source$.getValue === "function" ? source$.getValue() : options.defaultValue
-  );
-  const sourceRef = useLiveRef(source$);
-  const optionsRef = useLiveRef(options);
-  const getSnapshot = useCallback(() => {
-    return valueRef.current;
-  }, []);
-  const subscribe = useCallback(
-    (next) => {
-      const source = sourceRef.current;
-      const sub = makeObservable(source)().pipe(
-        optionsRef.current.defaultValue ? startWith(optionsRef.current.defaultValue) : identity,
+  }, s = !r && Array.isArray(t) ? t : typeof e == "function" ? r ?? [] : [e], a = I(
+    "getValue" in e && typeof e.getValue == "function" ? e.getValue() : n.defaultValue
+  ), u = h(e), i = h(n), c = v(() => a.current, []), o = v(
+    (l) => {
+      const m = u.current, b = k(m)().pipe(
+        i.current.defaultValue ? de(i.current.defaultValue) : Q,
         /**
          * @important there is already a Object.is comparison in place from react
          * so we only add a custom compareFn if provided
          */
-        optionsRef.current.compareFn ? distinctUntilChanged((a, b) => {
-          if (a === void 0 || b === void 0) return false;
-          return optionsRef.current.compareFn(a, b);
-        }) : identity,
-        tap((value) => {
-          valueRef.current = value;
+        i.current.compareFn ? J((d, y) => d === void 0 || y === void 0 ? !1 : i.current.compareFn(d, y)) : Q,
+        G((d) => {
+          a.current = d;
         }),
-        catchError((error) => {
-          console.error(error);
-          return EMPTY;
-        })
-      ).subscribe(next);
+        M((d) => (console.error(d), N))
+      ).subscribe(l);
       return () => {
-        if (optionsRef.current.unsubscribeOnUnmount === false) return;
-        sub.unsubscribe();
+        i.current.unsubscribeOnUnmount !== !1 && b.unsubscribe();
       };
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [...deps]
+    [...s]
   );
-  const result = useSyncExternalStore(subscribe, getSnapshot);
-  return result;
+  return ie(o, c);
 }
-function useSubscribe(source, deps = []) {
-  const sourceRef = useLiveRef(source);
-  useEffect(() => {
-    const sub = makeObservable(sourceRef.current)().pipe(
-      catchError((error) => {
-        console.error(error);
-        return EMPTY;
-      })
+function Qe(e, t = []) {
+  const r = h(e);
+  S(() => {
+    const n = k(r.current)().pipe(
+      M((s) => (console.error(s), N))
     ).subscribe();
     return () => {
-      sub.unsubscribe();
+      n.unsubscribe();
     };
   }, [
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    ...deps,
-    sourceRef
+    ...t,
+    r
   ]);
 }
-const useConstant = (fn) => {
-  const ref = useRef(void 0);
-  if (!ref.current) {
-    ref.current = fn();
-  }
-  useEffect(() => {
-    if (process.env.NODE_ENV === "development") ;
-  }, []);
-  return ref;
-};
-const useSubject = ({
-  onBeforeComplete,
-  completeOnUnmount = true
+const re = (e) => {
+  const t = I(void 0);
+  return t.current || (t.current = e()), S(() => {
+    process.env.NODE_ENV;
+  }, []), t;
+}, ne = ({
+  onBeforeComplete: e,
+  completeOnUnmount: t = !0
 } = {}) => {
-  const subject = useConstant(() => new Subject());
-  const completed = useRef(false);
-  const onBeforeCompleteRef = useLiveRef(onBeforeComplete);
-  const completeOnUnmountRef = useLiveRef(completeOnUnmount);
-  useEffect(() => {
-    if (completed.current) {
-      subject.current = new Subject();
-      completed.current = false;
+  const r = re(() => new H()), n = I(!1), s = h(e), a = h(t);
+  return S(() => (n.current && (r.current = new H(), n.current = !1), () => {
+    if (!a.current) {
+      n.current = !0;
+      return;
     }
-    return () => {
-      if (!completeOnUnmountRef.current) {
-        completed.current = true;
-        return;
-      }
-      if (!completed.current) {
-        if (onBeforeCompleteRef.current != null) onBeforeCompleteRef.current();
-        subject.current.complete();
-        completed.current = true;
-      }
-    };
-  }, [completeOnUnmountRef, onBeforeCompleteRef, subject]);
-  return subject;
-};
-const useObservableCallback = () => {
-  const subject = useSubject();
-  const trigger = useCallback(
-    (arg) => {
-      subject.current.next(arg);
+    n.current || (s.current != null && s.current(), r.current.complete(), n.current = !0);
+  }), [a, s, r]), r;
+}, Ce = () => {
+  const e = ne(), t = v(
+    (r) => {
+      e.current.next(r);
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []
   );
-  return [subject.current, trigger];
-};
-const useBehaviorSubject = (state) => {
-  const subject = useConstant(() => new BehaviorSubject(state));
-  const completed = useRef(false);
-  const stateRef = useRef(state);
-  useEffect(() => {
-    if (completed.current) {
-      subject.current = new BehaviorSubject(stateRef.current);
-      completed.current = false;
-    }
-    return () => {
-      if (!completed.current) {
-        subject.current.complete();
-        completed.current = true;
-      }
-    };
-  }, [subject]);
-  return subject;
-};
-const useObservableState = (defaultValue) => {
-  const subject = useBehaviorSubject(defaultValue);
-  const subject$ = useLiveRef(subject.current.asObservable());
-  const setState = useCallback(
-    (value) => {
-      subject.current.next(value);
+  return [e.current, t];
+}, j = (e) => {
+  const t = re(() => new F(e)), r = I(!1), n = I(e);
+  return S(() => (r.current && (t.current = new F(n.current), r.current = !1), () => {
+    r.current || (t.current.complete(), r.current = !0);
+  }), [t]), t;
+}, rt = (e) => {
+  const t = j(e), r = h(t.current.asObservable()), n = v(
+    (s) => {
+      t.current.next(s);
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [subject.current]
+    [t.current]
   );
-  return [subject$.current, setState, subject.current.getValue()];
-};
-const useLiveBehaviorSubject = (state) => {
-  const subject = useBehaviorSubject(state);
-  useEffect(() => {
-    subject.current.next(state);
-  }, [state, subject]);
-  return subject;
+  return [r.current, n, t.current.getValue()];
+}, L = (e) => {
+  const t = j(e);
+  return S(() => {
+    t.current.next(e);
+  }, [e, t]), t;
 };
-function useSubscribeEffect(source, unsafeOptions, deps = []) {
-  const options = unsafeOptions != null && !Array.isArray(unsafeOptions) ? unsafeOptions : {};
-  const retryOption = options.retry ?? true;
-  const onErrorRef = useLiveRef(
-    options.onError ?? ((error) => {
-      console.error(error);
+function nt(e, t, r = []) {
+  const n = t != null && !Array.isArray(t) ? t : {}, s = n.retry ?? !0, a = h(
+    n.onError ?? ((c) => {
+      console.error(c);
     })
-  );
-  const sourceAsObservable = useCallback(() => makeObservable(source)(), deps);
-  const enhancerMakeObservable = useCallback(
-    () => sourceAsObservable().pipe(
-      catchError((error) => {
-        onErrorRef.current(error);
-        throw error;
+  ), u = v(() => k(e)(), r), i = v(
+    () => u().pipe(
+      M((c) => {
+        throw a.current(c), c;
       }),
-      retryOption ? retry() : identity
+      s ? me() : Q
     ),
-    [sourceAsObservable, retryOption, onErrorRef]
+    [u, s, a]
   );
-  useSubscribe(enhancerMakeObservable, deps);
+  Qe(i, r);
 }
-const SIGNAL_RESET = Symbol("SIGNAL_RESET");
-function signal(config = {}) {
-  const normalizedConfig = {
-    default: config.default,
-    key: config.key
-  };
-  const { default: defaultValue } = normalizedConfig;
-  const subject = new BehaviorSubject(defaultValue);
-  const setValue = (arg) => {
-    const update = (value) => {
-      if ("key" in config) {
-        console.log(
-          "[reactjrx][state][signal]:",
-          `Value update for signal ${config.key}`,
-          { prev: subject.getValue(), curr: value }
-        );
-      }
-      subject.next(value);
+const Pe = Symbol("SIGNAL_RESET");
+function Ne(e = {}) {
+  const t = {
+    default: e.default,
+    key: e.key
+  }, { default: r } = t, n = new F(r), s = (u) => {
+    const i = (c) => {
+      "key" in e && console.log(
+        "[reactjrx][state][signal]:",
+        `Value update for signal ${e.key}`,
+        { prev: n.getValue(), curr: c }
+      ), n.next(c);
     };
-    if (typeof arg === "function") {
-      const change = arg(subject.getValue());
-      if (change === subject.getValue()) return;
-      return update(change);
-    }
-    if (arg === SIGNAL_RESET) {
-      if (defaultValue === subject.getValue()) return;
-      return update(defaultValue ?? void 0);
+    if (typeof u == "function") {
+      const c = u(n.getValue());
+      return c === n.getValue() ? void 0 : i(c);
     }
-    if (arg === subject.getValue()) return;
-    return update(arg);
-  };
-  const getValue = () => subject.getValue();
-  if ("get" in config) {
-    const getter = (signal2) => {
-      signal2.subject.pipe(skip(1), first()).subscribe(() => {
-        var _a;
-        const newValue = (_a = config.get) == null ? void 0 : _a.call(config, getter);
-        setValue(newValue);
-      });
-      return signal2.getValue();
-    };
-    const defaultValue2 = config.get(getter);
-    setValue(defaultValue2);
-    return {
-      getValue,
-      config,
-      subject
+    if (u === Pe)
+      return r === n.getValue() ? void 0 : i(r ?? void 0);
+    if (u !== n.getValue())
+      return i(u);
+  }, a = () => n.getValue();
+  if ("get" in e) {
+    const u = (c) => (c.subject.pipe(pe(1), W()).subscribe(() => {
+      var f;
+      const o = (f = e.get) == null ? void 0 : f.call(e, u);
+      s(o);
+    }), c.getValue()), i = e.get(u);
+    return s(i), {
+      getValue: a,
+      config: e,
+      subject: n
     };
   }
   return {
-    setValue,
-    getValue,
-    config: normalizedConfig,
-    subject
+    setValue: s,
+    getValue: a,
+    config: t,
+    subject: n
   };
 }
-function useSignalValue(signal2, selector) {
-  const defaultSelector = () => signal2.getValue();
-  const selectorOrDefault = selector ?? defaultSelector;
-  return useObserve(
-    () => {
-      const observed$ = signal2.subject.pipe(
-        map((value) => {
-          const selectedValue = selectorOrDefault(value);
-          return selectedValue;
-        }),
-        distinctUntilChanged()
-      );
-      return observed$;
-    },
+function ke(e, t) {
+  const n = t ?? (() => e.getValue());
+  return te(
+    () => e.subject.pipe(
+      C((a) => n(a)),
+      J()
+    ),
     {
-      defaultValue: selectorOrDefault(signal2.getValue())
+      defaultValue: n(e.getValue())
     },
     []
   );
 }
-const useSignal = (config) => {
-  const [stateSignal] = useState(() => signal(config));
-  const value = useSignalValue(stateSignal);
-  return [value, stateSignal];
-};
-const createLocalforageAdapter = (forage) => ({
-  getItem: async (key) => {
-    const serializedValue = await forage.getItem(key);
-    if (!serializedValue) return void 0;
-    return JSON.parse(serializedValue);
+const ut = (e) => {
+  const [t] = U(() => Ne(e));
+  return [ke(t), t];
+}, st = (e) => ({
+  getItem: async (t) => {
+    const r = await e.getItem(t);
+    if (r)
+      return JSON.parse(r);
   },
-  setItem: async (key, value) => {
-    await forage.setItem(key, JSON.stringify(value));
+  setItem: async (t, r) => {
+    await e.setItem(t, JSON.stringify(r));
   },
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  removeItem: async (_) => {
+  removeItem: async (t) => {
   },
   clear: async () => {
   }
-});
-const normalizeStore = (store) => {
-  if (!store || typeof store !== "object") {
-    return void 0;
-  }
-  return store;
-};
-const createSharedStoreAdapter = ({
-  adapter,
-  key
+}), A = (e) => {
+  if (!(!e || typeof e != "object"))
+    return e;
+}, je = ({
+  adapter: e,
+  key: t
 }) => ({
+  clear: async () => await e.removeItem(t),
+  removeItem: async (r) => {
+    const n = await e.getItem(t), { [r]: s, ...a } = A(n) ?? {};
+    await e.setItem(t, a);
+  },
+  getItem: async (r) => {
+    const n = await e.getItem(t), s = A(n) ?? {};
+    if (r in s)
+      return s[r];
+  },
+  setItem: async (r, n) => {
+    const s = await e.getItem(t), a = A(s) ?? {};
+    await e.setItem(t, { ...a, [r]: n });
+  }
+}), De = ({
+  key: e
+} = {}) => e ? je({
+  adapter: De(),
+  key: e
+}) : {
   clear: async () => {
-    return await adapter.removeItem(key);
+    localStorage.clear();
   },
-  removeItem: async (keyToDelete) => {
-    const unsafeStore = await adapter.getItem(key);
-    const { [keyToDelete]: toRemove, ...rest } = normalizeStore(unsafeStore) ?? {};
-    await adapter.setItem(key, rest);
+  removeItem: async (t) => {
+    localStorage.removeItem(t);
   },
-  getItem: async (itemKey) => {
-    const unsafeStore = await adapter.getItem(key);
-    const store = normalizeStore(unsafeStore) ?? {};
-    if (itemKey in store) {
-      return store[itemKey];
-    }
-    return void 0;
+  getItem: async (t) => {
+    const r = localStorage.getItem(t);
+    if (r)
+      return JSON.parse(r);
   },
-  setItem: async (itemKey, value) => {
-    const unsafeStore = await adapter.getItem(key);
-    const store = normalizeStore(unsafeStore) ?? {};
-    await adapter.setItem(key, { ...store, [itemKey]: value });
+  setItem: async (t, r) => {
+    localStorage.setItem(t, JSON.stringify(r));
   }
-});
-const createLocalStorageAdapter = ({
-  key
-} = {}) => {
-  if (key) {
-    return createSharedStoreAdapter({
-      adapter: createLocalStorageAdapter(),
-      key
-    });
-  }
-  return {
-    clear: async () => {
-      localStorage.clear();
-    },
-    removeItem: async (key2) => {
-      localStorage.removeItem(key2);
-    },
-    getItem: async (key2) => {
-      const serializedValue = localStorage.getItem(key2);
-      if (!serializedValue) return void 0;
-      return JSON.parse(serializedValue);
-    },
-    setItem: async (key2, value) => {
-      localStorage.setItem(key2, JSON.stringify(value));
-    }
-  };
-};
-const IDENTIFIER_PERSISTANCE_KEY = "__reactjrx";
-const getNormalizedPersistanceValue = (unknownValue) => {
-  if (typeof unknownValue === "object" && unknownValue !== null && IDENTIFIER_PERSISTANCE_KEY in unknownValue && unknownValue[IDENTIFIER_PERSISTANCE_KEY] === IDENTIFIER_PERSISTANCE_KEY) {
-    return unknownValue;
-  }
-  return void 0;
-};
-const persistValue = ({
-  adapter,
-  config
+}, w = "__reactjrx", _e = (e) => {
+  if (typeof e == "object" && e !== null && w in e && e[w] === w)
+    return e;
+}, He = ({
+  adapter: e,
+  config: t
 }) => {
-  const { signal: signal2, version } = config;
-  const state = signal2.getValue();
-  const value = {
-    value: state,
-    [IDENTIFIER_PERSISTANCE_KEY]: IDENTIFIER_PERSISTANCE_KEY,
-    migrationVersion: version
+  const { signal: r, version: n } = t, a = {
+    value: r.getValue(),
+    [w]: w,
+    migrationVersion: n
   };
-  if (process.env.NODE_ENV === "development") {
-    console.log(
-      "[reactjrx][state][persistance]:",
-      `Persist value`,
-      value,
-      `for signal ${signal2.config.key}`
-    );
-  }
-  return from(adapter.setItem(signal2.config.key, value)).pipe(
-    catchError((e) => {
-      console.error(e);
-      return of(null);
-    })
+  return process.env.NODE_ENV === "development" && console.log(
+    "[reactjrx][state][persistance]:",
+    "Persist value",
+    a,
+    `for signal ${r.config.key}`
+  ), E(e.setItem(r.config.key, a)).pipe(
+    M((u) => (console.error(u), p(null)))
   );
 };
-function hydrateValueToSignal({
-  adapter,
-  config
+function Ke({
+  adapter: e,
+  config: t
 }) {
-  const { hydrate = ({ value }) => value, signal: signal2, version } = config;
-  return from(adapter.getItem(signal2.config.key)).pipe(
-    switchMap((value) => {
-      const normalizedValue = getNormalizedPersistanceValue(value);
-      if (!normalizedValue) return of(value);
-      const storedVersionIsInvalid = typeof normalizedValue.migrationVersion !== "number";
-      const signalVersionIsSuperior = normalizedValue.migrationVersion !== void 0 && version > normalizedValue.migrationVersion;
-      if (storedVersionIsInvalid || signalVersionIsSuperior || normalizedValue.value === void 0) {
-        return of(value);
-      }
-      const correctVersionValue = normalizedValue.value;
-      if (process.env.NODE_ENV === "development") {
-        console.log(
-          "[reactjrx][state][persistance]:",
-          `Hydrate value`,
-          normalizedValue,
-          `for signal ${signal2.config.key}`
-        );
-      }
-      signal2.setValue(hydrate({ value: correctVersionValue, version }));
-      return of(value);
+  const { hydrate: r = ({ value: a }) => a, signal: n, version: s } = t;
+  return E(e.getItem(n.config.key)).pipe(
+    $((a) => {
+      const u = _e(a);
+      if (!u) return p(a);
+      const i = typeof u.migrationVersion != "number", c = u.migrationVersion !== void 0 && s > u.migrationVersion;
+      if (i || c || u.value === void 0)
+        return p(a);
+      const o = u.value;
+      return process.env.NODE_ENV === "development" && console.log(
+        "[reactjrx][state][persistance]:",
+        "Hydrate value",
+        u,
+        `for signal ${n.config.key}`
+      ), n.setValue(r({ value: o, version: s })), p(a);
     })
   );
 }
-function persistSignals({
-  entries = [],
-  onHydrated,
-  adapter
+function ze({
+  entries: e = [],
+  onHydrated: t,
+  adapter: r
 }) {
-  const signalsHydrated$ = entries.length === 0 ? of([]) : zip(
-    ...entries.map(
-      (config) => hydrateValueToSignal({
-        adapter,
-        config
+  const s = (e.length === 0 ? p([]) : be(
+    ...e.map(
+      (u) => Ke({
+        adapter: r,
+        config: u
       })
     )
-  );
-  const isHydrated$ = signalsHydrated$.pipe(
-    tap(onHydrated),
-    catchError((error) => {
-      console.error("Unable to hydrate", error);
-      return EMPTY;
-    }),
-    share()
-  );
-  const persisted$ = isHydrated$.pipe(
-    switchMap(
-      () => merge(
-        ...entries.map(
-          (config) => config.signal.subject.pipe(
-            throttleTime(500, asyncScheduler, {
-              trailing: true
+  )).pipe(
+    G(t),
+    M((u) => (console.error("Unable to hydrate", u), N)),
+    Y()
+  ), a = s.pipe(
+    $(
+      () => x(
+        ...e.map(
+          (u) => u.signal.subject.pipe(
+            ve(500, ge, {
+              trailing: !0
             }),
-            switchMap(
-              () => from(
-                persistValue({
-                  adapter,
-                  config
+            $(
+              () => E(
+                He({
+                  adapter: r,
+                  config: u
                 })
               )
             )
@@ -460,492 +324,394 @@ function persistSignals({
       )
     )
   );
-  return merge(
-    isHydrated$.pipe(
-      map(() => ({
+  return x(
+    s.pipe(
+      C(() => ({
         type: "hydrated"
       }))
     ),
-    persisted$.pipe(
-      map(() => ({
+    a.pipe(
+      C(() => ({
         type: "persisted"
       }))
     )
   );
 }
-function shallowEqual(objA, objB) {
-  if (objA === null || objA === void 0 || objB === void 0) {
-    return objA === objB;
-  }
-  if (typeof objA !== "object" || typeof objB !== "object") {
-    return objA === objB;
-  }
-  if (objA.constructor !== (objB == null ? void 0 : objB.constructor)) {
-    return false;
-  }
-  const keysA = Object.keys(objA);
-  const keysB = Object.keys(objB);
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-  for (const key of keysA) {
-    if (!objB.hasOwnProperty(key) || objA[key] !== objB[key]) {
-      return false;
-    }
-  }
-  return true;
+function Te(e, t) {
+  if (e == null || t === void 0 || typeof e != "object" || typeof t != "object")
+    return e === t;
+  if (e.constructor !== (t == null ? void 0 : t.constructor))
+    return !1;
+  const r = Object.keys(e), n = Object.keys(t);
+  if (r.length !== n.length)
+    return !1;
+  for (const s of r)
+    if (!t.hasOwnProperty(s) || e[s] !== t[s])
+      return !1;
+  return !0;
 }
-function usePersistSignals({
-  entries = [],
-  onHydrated,
-  adapter
+function ct({
+  entries: e = [],
+  onHydrated: t,
+  adapter: r
 }) {
-  const onHydratedRef = useLiveRef(onHydrated);
-  const adapterSubject = useLiveBehaviorSubject(adapter);
-  const entriesSubject = useLiveBehaviorSubject(entries);
-  return useObserve(
-    () => {
-      const persistence$ = adapterSubject.current.pipe(
-        switchMap((adapter2) => {
-          if (!adapter2) return of({ type: "reset" });
-          return merge(
-            of({ type: "reset" }),
-            entriesSubject.current.pipe(
-              concatMap(
-                (entries2) => persistSignals({
-                  adapter: adapter2,
-                  entries: entries2,
-                  onHydrated: () => {
-                    var _a;
-                    (_a = onHydratedRef.current) == null ? void 0 : _a.call(onHydratedRef);
-                  }
-                })
-              )
-            )
-          );
-        })
-      );
-      return persistence$.pipe(
-        scan(
-          (acc, event) => {
-            if (event.type === "reset") return { isHydrated: false };
-            if (event.type === "hydrated") return { isHydrated: true };
-            return acc;
-          },
-          { isHydrated: false }
+  const n = h(t), s = L(r), a = L(e);
+  return te(
+    () => s.current.pipe(
+      $((i) => i ? x(
+        p({ type: "reset" }),
+        a.current.pipe(
+          he(
+            (c) => ze({
+              adapter: i,
+              entries: c,
+              onHydrated: () => {
+                var o;
+                (o = n.current) == null || o.call(n);
+              }
+            })
+          )
         )
-      );
-    },
-    { defaultValue: { isHydrated: false }, compareFn: shallowEqual },
-    [adapterSubject, entriesSubject]
+      ) : p({ type: "reset" }))
+    ).pipe(
+      Se(
+        (i, c) => c.type === "reset" ? { isHydrated: !1 } : c.type === "hydrated" ? { isHydrated: !0 } : i,
+        { isHydrated: !1 }
+      )
+    ),
+    { defaultValue: { isHydrated: !1 }, compareFn: Te },
+    [s, a]
   );
 }
-const useUnmountObservable = () => {
-  const subject = useSubject({
+const at = () => {
+  const e = ne({
     onBeforeComplete: () => {
-      subject.current.next();
+      e.current.next();
     }
   });
-  return subject;
-};
-const useEffectOnce = (effect) => {
-  useEffect(effect, []);
-};
-const useMount = (fn) => {
-  useEffectOnce(() => {
-    fn();
+  return e;
+}, Le = (e) => {
+  S(e, []);
+}, ot = (e) => {
+  Le(() => {
+    e();
   });
 };
-function getDelay(backoffDelay, maxInterval) {
-  return Math.min(backoffDelay, maxInterval);
+function Ue(e, t) {
+  return Math.min(e, t);
 }
-function exponentialBackoffDelay(iteration, initialInterval) {
-  return Math.pow(2, iteration) * initialInterval;
+function Je(e, t) {
+  return Math.pow(2, e) * t;
 }
-function retryBackoff(config) {
+function it(e) {
   const {
-    retry: retry2,
-    retryDelay,
-    retryAfterDelay,
-    retryAfter = () => of(true)
-  } = config;
-  const maxRetries = typeof retry2 !== "function" ? retry2 === false ? 0 : retry2 === true ? Infinity : retry2 ?? Infinity : Infinity;
-  const shouldRetry = typeof retry2 === "function" ? (
+    retry: t,
+    retryDelay: r,
+    retryAfterDelay: n,
+    retryAfter: s = () => p(!0)
+  } = e, a = typeof t != "function" ? t === !1 ? 0 : t === !0 ? 1 / 0 : t ?? 1 / 0 : 1 / 0, u = typeof t == "function" ? (
     // ? (attempt: number, error: TError) => of(retry(attempt, error))
-    retry2
-  ) : () => true;
-  const initialInterval = typeof retryDelay === "number" ? retryDelay : 100;
-  const normalizedConfig = {
-    shouldRetry,
-    ...config
-  };
-  const {
-    maxInterval = Infinity,
-    resetOnSuccess = false,
-    backoffDelay = exponentialBackoffDelay
-  } = normalizedConfig;
-  return (source) => defer(() => {
-    let caughtErrors = 0;
-    const shouldRetryFn = (attempt, error) => attempt < maxRetries ? shouldRetry(attempt, error) : false;
-    return source.pipe(
-      catchError$1((error) => {
-        var _a;
-        caughtErrors++;
-        if (!shouldRetryFn(caughtErrors - 1, error)) throw error;
-        const caughtErrorResult$ = (_a = config.caughtError) == null ? void 0 : _a.call(config, caughtErrors, error);
-        if (!caughtErrorResult$) throw error;
-        return caughtErrorResult$.pipe(
-          mergeMap(
-            (source2) => merge(
-              of(source2),
-              throwError(() => error)
+    t
+  ) : () => !0, i = typeof r == "number" ? r : 100, c = {
+    shouldRetry: u,
+    ...e
+  }, {
+    maxInterval: o = 1 / 0,
+    resetOnSuccess: f = !1,
+    backoffDelay: l = Je
+  } = c;
+  return (m) => P(() => {
+    let b = 0;
+    const d = (y, g) => y < a ? u(y, g) : !1;
+    return m.pipe(
+      z((y) => {
+        var V;
+        if (b++, !d(b - 1, y)) throw y;
+        const g = (V = e.caughtError) == null ? void 0 : V.call(e, b, y);
+        if (!g) throw y;
+        return g.pipe(
+          R(
+            (q) => x(
+              p(q),
+              O(() => y)
             )
           )
         );
       }),
-      retryWhen((errors) => {
-        return errors.pipe(
-          concatMap$1((error) => {
-            const attempt = caughtErrors - 1;
-            return retryAfter().pipe(
-              first$1(),
-              mergeMap(
-                () => shouldRetryFn(attempt, error) ? timer(
-                  getDelay(
-                    backoffDelay(attempt, initialInterval),
-                    maxInterval
-                  )
-                ).pipe(
-                  mergeMap((timer2) => {
-                    if (retryAfterDelay && !retryAfterDelay(attempt, error))
-                      return throwError(() => error);
-                    return of(timer2);
-                  })
-                ) : throwError(() => error)
-              )
-            );
-          })
-        );
-      }),
-      catchError$1((e) => {
-        if (config.catchError) {
-          return config.catchError(caughtErrors, e);
-        }
-        throw e;
+      Me((y) => y.pipe(
+        Fe((g) => {
+          const V = b - 1;
+          return s().pipe(
+            xe(),
+            R(
+              () => d(V, g) ? Ve(
+                Ue(
+                  l(V, i),
+                  o
+                )
+              ).pipe(
+                R((q) => n && !n(V, g) ? O(() => g) : p(q))
+              ) : O(() => g)
+            )
+          );
+        })
+      )),
+      z((y) => {
+        if (e.catchError)
+          return e.catchError(b, y);
+        throw y;
       }),
-      tap$1(() => {
-        if (resetOnSuccess) {
-          caughtErrors = 0;
-        }
+      qe(() => {
+        f && (b = 0);
       })
     );
   });
 }
-function isDefined(arg) {
-  return arg !== null && arg !== void 0;
+function lt(e) {
+  return e != null;
 }
-const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
-const isServer = typeof window === "undefined" || "Deno" in window;
-class QueryClient$ {
+const ft = (e, t) => e.length === t.length && e.every((r, n) => r === t[n]), yt = typeof window > "u" || "Deno" in window;
+class Ge {
   constructor() {
-    __publicField(this, "queryMap", /* @__PURE__ */ new Map());
+    D(this, "queryMap", /* @__PURE__ */ new Map());
   }
-  getQuery(queryHash) {
-    return this.queryMap.get(queryHash);
+  getQuery(t) {
+    return this.queryMap.get(t);
   }
-  setQuery(queryKey, query$, signal2) {
-    const queryHash = hashKey(queryKey);
-    const sharedQuery$ = query$.pipe(
+  setQuery(t, r, n) {
+    const s = B(t), a = r.pipe(
       /**
        * abort signal is triggered on:
        * - manual cancellation from user
        * - unmounting the component
        * @see https://tanstack.com/query/latest/docs/framework/react/guides/query-cancellation
        */
-      takeUntil(fromEvent(signal2, "abort")),
-      share()
-    );
-    const cacheEntry = {
-      query$: sharedQuery$,
-      signal: signal2,
+      X(Ie(n, "abort")),
+      Y()
+    ), u = {
+      query$: a,
+      signal: n,
       sub: void 0,
-      isCompleted: false,
+      isCompleted: !1,
       lastData: void 0
     };
-    this.queryMap.set(queryHash, cacheEntry);
-    const sub = sharedQuery$.subscribe({
-      next: (data) => {
-        const entry = this.queryMap.get(queryHash);
-        if (entry) {
-          entry.lastData = { value: data };
-        }
+    this.queryMap.set(s, u);
+    const i = a.subscribe({
+      next: (c) => {
+        const o = this.queryMap.get(s);
+        o && (o.lastData = { value: c });
       },
       complete: () => {
-        this.deleteQuery(queryHash);
+        this.deleteQuery(s);
       }
     });
-    cacheEntry.sub = sub;
-    return cacheEntry;
+    return u.sub = i, u;
   }
-  deleteQuery(queryHash) {
-    const entry = this.queryMap.get(queryHash);
-    if (!entry) return;
-    if (entry.sub) {
-      entry.sub.unsubscribe();
-      entry.sub = void 0;
-    }
-    entry.isCompleted = true;
-    this.queryMap.delete(queryHash);
+  deleteQuery(t) {
+    const r = this.queryMap.get(t);
+    r && (r.sub && (r.sub.unsubscribe(), r.sub = void 0), r.isCompleted = !0, this.queryMap.delete(t));
   }
   destroy() {
-    this.queryMap.forEach((_, key) => {
-      this.deleteQuery(key);
+    this.queryMap.forEach((t, r) => {
+      this.deleteQuery(r);
     });
   }
 }
-const Context = createContext(void 0);
-const QueryClientProvider$ = memo(
+const ue = le(void 0), dt = fe(
   ({
-    children,
-    client: _client
+    children: e,
+    client: t
   }) => {
-    const [client] = useState(() => _client ?? new QueryClient$());
-    useEffect(() => {
-      return () => {
-        client.destroy();
-      };
-    }, [client]);
-    return /* @__PURE__ */ jsx(Context.Provider, { value: client, children });
+    const [r] = U(() => t ?? new Ge());
+    return S(() => () => {
+      r.destroy();
+    }, [r]), /* @__PURE__ */ Ae(ue.Provider, { value: r, children: e });
   }
-);
-const useQueryClient$ = () => {
-  const client = useContext(Context);
-  if (!client) {
+), We = () => {
+  const e = ye(ue);
+  if (!e)
     throw new Error(
       "useReactJrxQueryClient must be used within a ReactJrxQueryProvider"
     );
-  }
-  return client;
+  return e;
 };
-function useQuery$(options, queryClient) {
-  const _queryClient = useQueryClient(queryClient);
-  const queryClient$ = useQueryClient$();
-  const queryFnAsync = (context) => {
-    return new Promise((resolve, reject) => {
-      const getSource = () => defer(
-        () => typeof options.queryFn === "function" ? options.queryFn(context) : options.queryFn
-      );
-      const queryHash = hashKey(context.queryKey);
-      const queryCacheEntry = queryClient$.getQuery(queryHash) ?? queryClient$.setQuery(context.queryKey, getSource(), context.signal);
-      const query$ = queryCacheEntry.query$;
-      query$.pipe(
-        take(1),
-        /**
-         * If several values are emitted during this delay, we will only
-         * keep the last value. This is unfortunate but it's the best we can do
-         * for now.
-         */
-        delay(1)
-      ).subscribe({
-        error: (error) => {
-          return reject(error);
-        },
-        complete: () => {
-          if ((queryCacheEntry == null ? void 0 : queryCacheEntry.lastData) === void 0) {
-            if (queryCacheEntry.signal.aborted) {
-              return resolve(void 0);
-            }
-            console.log(
-              `cancelled due to stream completing without data for query ${queryHash}`,
-              queryCacheEntry == null ? void 0 : queryCacheEntry.lastData
-            );
-            _queryClient.cancelQueries({
-              queryKey: context.queryKey,
-              exact: true
-            });
-            return resolve(void 0);
-          }
-          resolve(queryCacheEntry.lastData.value);
-          if ((queryCacheEntry == null ? void 0 : queryCacheEntry.isCompleted) === false) {
-            setTimeout(() => {
-              _queryClient == null ? void 0 : _queryClient.refetchQueries({
-                queryKey: context.queryKey,
-                exact: true
+function mt(e, t) {
+  const r = ee(t), n = We();
+  return Oe(
+    {
+      ...e,
+      queryFn: (u) => new Promise((i, c) => {
+        const o = () => P(
+          () => typeof e.queryFn == "function" ? e.queryFn(u) : e.queryFn
+        ), f = B(u.queryKey), l = n.getQuery(f) ?? n.setQuery(u.queryKey, o(), u.signal);
+        l.query$.pipe(
+          Z(1),
+          /**
+           * If several values are emitted during this delay, we will only
+           * keep the last value. This is unfortunate but it's the best we can do
+           * for now.
+           */
+          we(1)
+        ).subscribe({
+          error: (b) => c(b),
+          complete: () => {
+            if ((l == null ? void 0 : l.lastData) === void 0)
+              return l.signal.aborted || (console.log(
+                `cancelled due to stream completing without data for query ${f}`,
+                l == null ? void 0 : l.lastData
+              ), r.cancelQueries({
+                queryKey: u.queryKey,
+                exact: !0
+              })), i(void 0);
+            i(l.lastData.value), (l == null ? void 0 : l.isCompleted) === !1 && setTimeout(() => {
+              r == null || r.refetchQueries({
+                queryKey: u.queryKey,
+                exact: !0
               });
             });
           }
-        }
-      });
-    });
-  };
-  const result = useQuery(
-    {
-      ...options,
-      queryFn: queryFnAsync
+        });
+      })
     },
-    queryClient
+    t
   );
-  return result;
 }
-function useMutation$(options, queryClient) {
-  const stateSubject = useBehaviorSubject({
+function se(e, t) {
+  const r = j({
     status: "idle",
-    isPending: false,
-    isError: false,
-    isSuccess: false,
-    isIdle: true
-  });
-  const result = useMutation(
+    isPending: !1,
+    isError: !1,
+    isSuccess: !1,
+    isIdle: !0
+  }), n = Re(
     {
-      ...options,
-      mutationFn: (variables) => {
-        let lastData;
-        return new Promise((resolve, reject) => {
-          const source = typeof options.mutationFn === "function" ? options.mutationFn(variables) : options.mutationFn;
-          source.pipe(take(1)).subscribe({
-            next: (data) => {
-              lastData = { value: data };
+      ...e,
+      mutationFn: (o) => {
+        let f;
+        return new Promise((l, m) => {
+          (typeof e.mutationFn == "function" ? e.mutationFn(o) : e.mutationFn).pipe(Z(1)).subscribe({
+            next: (d) => {
+              f = { value: d };
             },
-            error: (error) => {
-              reject(error);
+            error: (d) => {
+              m(d);
             },
             complete: () => {
-              if (lastData === void 0)
-                return reject(new Error("Stream completed without any data"));
-              resolve(lastData.value);
+              if (f === void 0)
+                return m(new Error("Stream completed without any data"));
+              l(f.value);
             }
           });
         });
       }
     },
-    queryClient
-  );
-  const { status, isPending, isError, isSuccess, isIdle } = result;
-  useEffect(() => {
-    stateSubject.current.next({ status, isPending, isError, isSuccess, isIdle });
-  }, [status, isPending, isError, isSuccess, isIdle, stateSubject]);
-  return { ...result, state$: stateSubject.current };
+    t
+  ), { status: s, isPending: a, isError: u, isSuccess: i, isIdle: c } = n;
+  return S(() => {
+    r.current.next({ status: s, isPending: a, isError: u, isSuccess: i, isIdle: c });
+  }, [s, a, u, i, c, r]), { ...n, state$: r.current };
 }
-function useSwitchMutation$(options, queryClient) {
-  const [cancel$, cancel] = useObservableCallback();
-  const { mutate, mutateAsync, ...rest } = useMutation$(
+function pt(e, t) {
+  const [r, n] = Ce(), { mutate: s, mutateAsync: a, ...u } = se(
     {
-      ...options,
-      mutationFn: (variables) => {
-        const source = typeof options.mutationFn === "function" ? options.mutationFn(variables) : options.mutationFn;
-        return source.pipe(takeUntil(cancel$), defaultIfEmpty(null));
-      }
+      ...e,
+      mutationFn: (o) => (typeof e.mutationFn == "function" ? e.mutationFn(o) : e.mutationFn).pipe(X(r), Ee(null))
     },
-    queryClient
+    t
+  ), i = v(
+    (o) => (n(), s(o)),
+    [s, n]
+  ), c = v(
+    (o) => (n(), a(o)),
+    [a, n]
   );
-  const mutateSwitch = useCallback(
-    (variables) => {
-      cancel();
-      return mutate(variables);
-    },
-    [mutate, cancel]
-  );
-  const mutateAsyncSwitch = useCallback(
-    (variables) => {
-      cancel();
-      return mutateAsync(variables);
-    },
-    [mutateAsync, cancel]
-  );
-  return { ...rest, mutate: mutateSwitch, mutateAsync: mutateAsyncSwitch };
+  return { ...u, mutate: i, mutateAsync: c };
 }
-function useContactMutation$(options, queryClient) {
-  const client = useQueryClient(queryClient);
-  const mutationKey = options.mutationKey;
-  const { mutateAsync, ...rest } = useMutation$(
+function bt(e, t) {
+  const r = ee(t), n = e.mutationKey, { mutateAsync: s, ...a } = se(
     {
-      ...options,
-      onMutate({ variables }) {
-        var _a;
-        return (_a = options.onMutate) == null ? void 0 : _a.call(options, variables);
+      ...e,
+      onMutate({ variables: c }) {
+        var o;
+        return (o = e.onMutate) == null ? void 0 : o.call(e, c);
       },
-      onSuccess(data, variables, context) {
-        var _a;
-        return (_a = options.onSuccess) == null ? void 0 : _a.call(options, data, variables.variables, context);
+      onSuccess(c, o, f) {
+        var l;
+        return (l = e.onSuccess) == null ? void 0 : l.call(e, c, o.variables, f);
       },
-      onError(error, variables, context) {
-        var _a;
-        return (_a = options.onError) == null ? void 0 : _a.call(options, error, variables.variables, context);
+      onError(c, o, f) {
+        var l;
+        return (l = e.onError) == null ? void 0 : l.call(e, c, o.variables, f);
       },
-      onSettled(data, error, variables, context) {
-        var _a;
-        return (_a = options.onSettled) == null ? void 0 : _a.call(options, data, error, variables.variables, context);
+      onSettled(c, o, f, l) {
+        var m;
+        return (m = e.onSettled) == null ? void 0 : m.call(e, c, o, f.variables, l);
       },
-      mutationFn: ({ ready$, variables }) => {
-        const source = typeof options.mutationFn === "function" ? options.mutationFn(variables) : options.mutationFn;
-        return ready$.pipe(
-          filter((isReady) => isReady),
-          first(),
-          switchMap(() => source)
+      mutationFn: ({ ready$: c, variables: o }) => {
+        const f = typeof e.mutationFn == "function" ? e.mutationFn(o) : e.mutationFn;
+        return c.pipe(
+          $e((l) => l),
+          W(),
+          $(() => f)
         );
       }
     },
-    queryClient
-  );
-  const mutateAsyncConcat = useCallback(
-    async (variables) => {
-      const mutations = client.getMutationCache().findAll({
-        mutationKey,
-        exact: true
-      });
-      const subject = new BehaviorSubject(false);
-      const result = mutateAsync({ variables, ready$: subject });
-      await Promise.all(
-        mutations.map((mutation) => mutation.continue().catch(noop))
-      );
-      subject.next(true);
-      return await result.finally(() => {
-        subject.complete();
+    t
+  ), u = v(
+    async (c) => {
+      const o = r.getMutationCache().findAll({
+        mutationKey: n,
+        exact: !0
+      }), f = new F(!1), l = s({ variables: c, ready$: f });
+      return await Promise.all(
+        o.map((m) => m.continue().catch(K))
+      ), f.next(!0), await l.finally(() => {
+        f.complete();
       });
     },
-    [mutateAsync, client, mutationKey]
-  );
-  const mutateConcat = useCallback(
-    (variables) => {
-      mutateAsyncConcat(variables).catch(noop);
+    [s, r, n]
+  ), i = v(
+    (c) => {
+      u(c).catch(K);
     },
-    [mutateAsyncConcat]
+    [u]
   );
-  return { ...rest, mutate: mutateConcat, mutateAsync: mutateAsyncConcat };
+  return { ...a, mutate: i, mutateAsync: u };
 }
 export {
-  Context,
-  QueryClient$,
-  QueryClientProvider$,
-  SIGNAL_RESET,
-  arrayEqual,
-  createLocalStorageAdapter,
-  createLocalforageAdapter,
-  exponentialBackoffDelay,
-  getDelay,
-  isDefined,
-  isPromiseLike,
-  isServer,
-  retryBackoff,
-  signal,
-  useBehaviorSubject,
-  useContactMutation$,
-  useEffectOnce,
-  useLiveBehaviorSubject,
-  useLiveRef,
-  useMount,
-  useMutation$,
-  useObservableCallback,
-  useObservableState,
-  useObserve,
-  usePersistSignals,
-  useQuery$,
-  useQueryClient$,
-  useSignal,
-  useSignalValue,
-  useSubject,
-  useSubscribe,
-  useSubscribeEffect,
-  useSwitchMutation$,
-  useUnmountObservable
+  ue as Context,
+  Ge as QueryClient$,
+  dt as QueryClientProvider$,
+  Pe as SIGNAL_RESET,
+  ft as arrayEqual,
+  De as createLocalStorageAdapter,
+  st as createLocalforageAdapter,
+  Je as exponentialBackoffDelay,
+  Ue as getDelay,
+  lt as isDefined,
+  T as isPromiseLike,
+  yt as isServer,
+  it as retryBackoff,
+  Ne as signal,
+  j as useBehaviorSubject,
+  bt as useContactMutation$,
+  Le as useEffectOnce,
+  L as useLiveBehaviorSubject,
+  h as useLiveRef,
+  ot as useMount,
+  se as useMutation$,
+  Ce as useObservableCallback,
+  rt as useObservableState,
+  te as useObserve,
+  ct as usePersistSignals,
+  mt as useQuery$,
+  We as useQueryClient$,
+  ut as useSignal,
+  ke as useSignalValue,
+  ne as useSubject,
+  Qe as useSubscribe,
+  nt as useSubscribeEffect,
+  pt as useSwitchMutation$,
+  at as useUnmountObservable
 };
+//# sourceMappingURL=index.js.map