reactjrx 1.46.0 → 1.48.0

package/dist/index.cjs

@@ -1,9 +1,15 @@
 "use strict";
+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);
+  return value;
+};
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const react = require("react");
 const rxjs = require("rxjs");
-const jsxRuntime = require("react/jsx-runtime");
 const operators = require("rxjs/operators");
+const jsxRuntime = require("react/jsx-runtime");
 const useLiveRef = (value) => {
   const ref = react.useRef(value);
   react.useMemo(() => {
@@ -163,12 +169,10 @@ const useBehaviorSubject = (state) => {
   return subject;
 };
 const SIGNAL_RESET = Symbol("SIGNAL_RESET");
-function signal(options) {
-  const { default: defaultValue2 } = options ?? {};
+function signal(config) {
+  const { default: defaultValue2 } = config ?? {};
   const subject = new rxjs.BehaviorSubject(defaultValue2);
   const setValue = (arg) => {
-    if (arg === subject.getValue())
-      return;
     if (typeof arg === "function") {
       const change = arg(subject.getValue());
       if (change === subject.getValue())
@@ -184,166 +188,15 @@ function signal(options) {
   };
   const getValue = () => subject.getValue();
   return {
-    setState: setValue,
+    setValue,
     getValue,
-    options,
-    /**
-     * @important
-     * We return the original behavior subject for two reasons:
-     * - useObserve may return the default value directly instead of undefined
-     * - the scope exist for react binding, this observable is a direct access outside of it
-     */
+    config,
     subject
   };
 }
-const useSetSignal = (signal2) => {
-  return signal2.setState;
-};
 const useSignalValue = (signal2, key) => {
   return useObserve(signal2.subject, { defaultValue: signal2.getValue(), key });
 };
-const useSignal = (signal2) => {
-  return [useSignalValue(signal2), useSetSignal(signal2)];
-};
-const useScopeSignals = (signals) => {
-  const signalsRef = useLiveRef(signals);
-  react.useEffect(
-    () => () => {
-      signalsRef.current.forEach(({ setState }) => {
-        setState(SIGNAL_RESET);
-      });
-    },
-    []
-  );
-};
-const createLocalStorageAdapter = (forage) => ({
-  getItem: async (key) => {
-    const serializedValue = forage.getItem(key);
-    if (!serializedValue)
-      return void 0;
-    return JSON.parse(serializedValue);
-  },
-  setItem: async (key, value) => {
-    forage.setItem(key, JSON.stringify(value));
-  }
-});
-const PersistSignalsContext = react.createContext({
-  resetSignals: () => {
-  }
-});
-const usePersistSignalsContext = () => react.useContext(PersistSignalsContext);
-const PersistSignals = react.memo(
-  ({
-    children,
-    signals = [],
-    onReady,
-    adapter = createLocalStorageAdapter(localStorage)
-  }) => {
-    const persistanceRef = useLiveRef(signals);
-    const onReadyRef = useLiveRef(onReady);
-    const adapterRef = useLiveRef(adapter);
-    const resetSignalSubject = useSubject();
-    const resetSignals = react.useCallback(() => {
-      persistanceRef.current.forEach(({ setValue }) => {
-        setValue(SIGNAL_RESET);
-      });
-      resetSignalSubject.current.next();
-    }, []);
-    const value = react.useMemo(() => ({ resetSignals }), [resetSignals]);
-    const isHydrated = useObserve(() => {
-      const items = persistanceRef.current;
-      const stream = items.length === 0 ? rxjs.of(true) : rxjs.zip(
-        ...items.map(
-          ({ hydrateValue }) => rxjs.from(hydrateValue({ adapter: adapterRef.current }))
-        )
-      ).pipe(rxjs.map(() => true));
-      return stream.pipe(
-        rxjs.tap(() => {
-          if (onReadyRef.current != null)
-            onReadyRef.current();
-        }),
-        rxjs.catchError((error) => {
-          console.error("Unable to hydrate", error);
-          return rxjs.EMPTY;
-        })
-      );
-    }, []) ?? false;
-    useSubscribe(
-      () => !isHydrated ? rxjs.EMPTY : rxjs.merge(
-        ...persistanceRef.current.map(
-          ({ persistValue, $ }) => (
-            // @todo test the reset
-            rxjs.merge(
-              resetSignalSubject.current,
-              $.pipe(
-                rxjs.throttleTime(500, void 0, {
-                  trailing: true,
-                  leading: false
-                })
-              )
-            ).pipe(rxjs.switchMap(() => rxjs.from(persistValue({ adapter }))))
-          )
-        )
-      ),
-      [isHydrated, adapter]
-    );
-    return isHydrated ? /* @__PURE__ */ jsxRuntime.jsx(PersistSignalsContext.Provider, { value, children }) : null;
-  }
-);
-const getNormalizedPersistanceValue = (unknownValue) => {
-  if (unknownValue === null)
-    return void 0;
-  if (typeof unknownValue === "object" && "__key" in unknownValue && unknownValue.__key === "reactjrx_persistance") {
-    return unknownValue;
-  }
-  return void 0;
-};
-function withPersistance(_signal, { version = 0 } = {}) {
-  if (!_signal.options.key) {
-    console.error(
-      "You need to specify a key to use persistance with this signal"
-    );
-  }
-  const hydrateValue = async ({
-    adapter,
-    key = _signal.options.key
-  }) => {
-    if (!key)
-      return;
-    const value = await adapter.getItem(key);
-    const normalizedValue = getNormalizedPersistanceValue(value);
-    if (normalizedValue == null)
-      return;
-    if (normalizedValue.migrationVersion && version > normalizedValue.migrationVersion) {
-      return;
-    }
-    _signal.setState(value.value);
-  };
-  const persistValue = async ({
-    adapter,
-    key = _signal.options.key
-  }) => {
-    if (!key)
-      return;
-    const state = _signal.getValue();
-    const value = {
-      value: state,
-      __key: "reactjrx_persistance",
-      migrationVersion: version
-    };
-    await adapter.setItem(key, value);
-  };
-  return [
-    {
-      hydrateValue,
-      persistValue,
-      setValue: _signal.setState,
-      $: _signal.subject,
-      options: _signal.options
-    },
-    _signal
-  ];
-}
 const normalizeStore = (store) => {
   if (!store || typeof store !== "object") {
     return void 0;
@@ -379,6 +232,107 @@ const createLocalforageAdapter = (forage) => ({
     await forage.setItem(key, JSON.stringify(value));
   }
 });
+const createLocalStorageAdapter = (forage) => ({
+  getItem: async (key) => {
+    const serializedValue = forage.getItem(key);
+    if (!serializedValue)
+      return void 0;
+    return JSON.parse(serializedValue);
+  },
+  setItem: async (key, value) => {
+    forage.setItem(key, 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 = async ({
+  adapter,
+  signal: signal2,
+  version
+}) => {
+  const state = signal2.getValue();
+  const value = {
+    value: state,
+    [IDENTIFIER_PERSISTANCE_KEY]: IDENTIFIER_PERSISTANCE_KEY,
+    migrationVersion: version
+  };
+  await adapter.setItem(signal2.config.key, value);
+};
+const hydrateValueToSignal = ({
+  adapter,
+  version,
+  signal: signal2
+}) => {
+  return rxjs.from(adapter.getItem(signal2.config.key)).pipe(
+    rxjs.switchMap((value) => {
+      const normalizedValue = getNormalizedPersistanceValue(value);
+      if (!normalizedValue)
+        return rxjs.of(value);
+      if (normalizedValue.migrationVersion !== void 0 && version > normalizedValue.migrationVersion) {
+        return rxjs.of(value);
+      }
+      signal2.setValue(value.value);
+      return rxjs.of(value);
+    })
+  );
+};
+const usePersistSignals = ({
+  entries = [],
+  onReady,
+  adapter = createLocalStorageAdapter(localStorage)
+}) => {
+  const entriesRef = useLiveRef(entries);
+  const onReadyRef = useLiveRef(onReady);
+  const adapterRef = useLiveRef(adapter);
+  const isHydrated = useObserve(
+    () => {
+      const entries2 = entriesRef.current;
+      const stream = entries2.length === 0 ? rxjs.of(true) : rxjs.zip(
+        ...entries2.map(
+          ({ signal: signal2, version }) => hydrateValueToSignal({
+            adapter: adapterRef.current,
+            signal: signal2,
+            version
+          })
+        )
+      ).pipe(rxjs.map(() => true));
+      return stream.pipe(
+        rxjs.tap(() => {
+          if (onReadyRef.current != null)
+            onReadyRef.current();
+        }),
+        rxjs.catchError((error) => {
+          console.error("Unable to hydrate", error);
+          return rxjs.EMPTY;
+        })
+      );
+    },
+    { defaultValue: false },
+    []
+  );
+  useSubscribe(() => {
+    return !isHydrated ? rxjs.EMPTY : rxjs.merge(
+      ...entriesRef.current.map(
+        ({ signal: signal2, version }) => signal2.subject.pipe(
+          rxjs.throttleTime(500, rxjs.asyncScheduler, {
+            trailing: true
+          }),
+          rxjs.switchMap(
+            () => rxjs.from(
+              persistValue({ adapter: adapterRef.current, signal: signal2, version })
+            )
+          )
+        )
+      )
+    );
+  }, [isHydrated, adapterRef]);
+  return { isHydrated };
+};
 const useUnmountObservable = () => {
   const subject = useSubject({
     onBeforeComplete: () => {
@@ -611,11 +565,8 @@ const ClientEffect = ({
   return null;
 };
 const Provider = react.memo(
-  ({
-    children,
-    client
-  }) => {
-    const value = react.useMemo(() => ({ client }), [client]);
+  ({ children, client }) => {
+    const value = react.useMemo(() => ({ client: client.client }), [client]);
     return /* @__PURE__ */ jsxRuntime.jsxs(Context.Provider, { value, children: [
       /* @__PURE__ */ jsxRuntime.jsx(ClientEffect, { client: value.client }),
       children
@@ -1703,8 +1654,14 @@ const createClient = () => {
     ...refetchClient
   };
 };
-exports.PersistSignals = PersistSignals;
-exports.ReactjrxQueryProvider = Provider;
+class QueryClient {
+  constructor() {
+    __publicField(this, "client");
+    this.client = createClient();
+  }
+}
+exports.QueryClient = QueryClient;
+exports.QueryClientProvider = Provider;
 exports.SIGNAL_RESET = SIGNAL_RESET;
 exports.createClient = createClient;
 exports.createLocalforageAdapter = createLocalforageAdapter;
@@ -1719,15 +1676,11 @@ exports.useBehaviorSubject = useBehaviorSubject;
 exports.useLiveRef = useLiveRef;
 exports.useObserve = useObserve;
 exports.useObserveCallback = useObserveCallback;
-exports.usePersistSignalsContext = usePersistSignalsContext;
+exports.usePersistSignals = usePersistSignals;
 exports.useQuery = useQuery;
 exports.useQueryClient = useQueryClient;
-exports.useScopeSignals = useScopeSignals;
-exports.useSetSignal = useSetSignal;
-exports.useSignal = useSignal;
 exports.useSignalValue = useSignalValue;
 exports.useSubject = useSubject;
 exports.useSubscribe = useSubscribe;
 exports.useSubscribeEffect = useSubscribeEffect;
 exports.useUnmountObservable = useUnmountObservable;
-exports.withPersistance = withPersistance;

package/dist/index.d.ts

@@ -5,15 +5,11 @@ export * from "./lib/binding/trigger";
 export * from "./lib/binding/useSubject";
 export * from "./lib/binding/useBehaviorSubject";
 export * from "./lib/state/signal";
-export * from "./lib/state/useSignal";
-export * from "./lib/state/useSetSignal";
 export * from "./lib/state/useSignalValue";
-export * from "./lib/state/useScopeSignals";
 export * from "./lib/state/constants";
-export * from "./lib/state/persistance/PersistSignals";
-export * from "./lib/state/persistance/withPersistance";
-export * from "./lib/state/persistance/createSharedStoreAdapter";
-export * from "./lib/state/persistance/createLocalforageAdapter";
+export * from "./lib/state/persistance/adapters/createSharedStoreAdapter";
+export * from "./lib/state/persistance/adapters/createLocalforageAdapter";
+export * from "./lib/state/persistance/usePersistSignals";
 export * from "./lib/utils/useUnmountObservable";
 export * from "./lib/utils/retryBackoff";
 export * from "./lib/utils/useLiveRef";
@@ -21,4 +17,4 @@ export * from "./lib/queries/react/useAsyncQuery";
 export * from "./lib/queries/react/useQuery";
 export * from "./lib/queries/react/useSubscribeEffect";
 export * from "./lib/queries/client/createClient";
-export { Provider as ReactjrxQueryProvider, useQueryClient } from "./lib/queries/react/Provider";
+export { Provider as QueryClientProvider, useQueryClient } from "./lib/queries/react/Provider";

package/dist/index.js

@@ -1,7 +1,13 @@
+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);
+  return value;
+};
 import { useRef, useMemo, useCallback, useSyncExternalStore, useEffect, createContext, memo, useContext } from "react";
-import { distinctUntilChanged, tap, finalize, catchError, EMPTY, Subject, identity, BehaviorSubject, of, zip, from, map, merge, throttleTime, switchMap, defer, iif, timer, throwError, scan, take, startWith, combineLatest, first, takeUntil, filter, concatMap as concatMap$1, mergeMap, fromEvent, skip, withLatestFrom, retry, shareReplay, endWith, delay, share, pairwise, NEVER, takeWhile } from "rxjs";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { distinctUntilChanged, tap, finalize, catchError, EMPTY, Subject, identity, BehaviorSubject, of, zip, map, merge, throttleTime, asyncScheduler, switchMap, from, defer, iif, timer, throwError, scan, take, startWith, combineLatest, first, takeUntil, filter, concatMap as concatMap$1, mergeMap, fromEvent, skip, withLatestFrom, retry, shareReplay, endWith, delay, share, pairwise, NEVER, takeWhile } from "rxjs";
 import { retryWhen, concatMap, tap as tap$1 } from "rxjs/operators";
+import { jsxs, jsx } from "react/jsx-runtime";
 const useLiveRef = (value) => {
   const ref = useRef(value);
   useMemo(() => {
@@ -161,12 +167,10 @@ const useBehaviorSubject = (state) => {
   return subject;
 };
 const SIGNAL_RESET = Symbol("SIGNAL_RESET");
-function signal(options) {
-  const { default: defaultValue2 } = options ?? {};
+function signal(config) {
+  const { default: defaultValue2 } = config ?? {};
   const subject = new BehaviorSubject(defaultValue2);
   const setValue = (arg) => {
-    if (arg === subject.getValue())
-      return;
     if (typeof arg === "function") {
       const change = arg(subject.getValue());
       if (change === subject.getValue())
@@ -182,166 +186,15 @@ function signal(options) {
   };
   const getValue = () => subject.getValue();
   return {
-    setState: setValue,
+    setValue,
     getValue,
-    options,
-    /**
-     * @important
-     * We return the original behavior subject for two reasons:
-     * - useObserve may return the default value directly instead of undefined
-     * - the scope exist for react binding, this observable is a direct access outside of it
-     */
+    config,
     subject
   };
 }
-const useSetSignal = (signal2) => {
-  return signal2.setState;
-};
 const useSignalValue = (signal2, key) => {
   return useObserve(signal2.subject, { defaultValue: signal2.getValue(), key });
 };
-const useSignal = (signal2) => {
-  return [useSignalValue(signal2), useSetSignal(signal2)];
-};
-const useScopeSignals = (signals) => {
-  const signalsRef = useLiveRef(signals);
-  useEffect(
-    () => () => {
-      signalsRef.current.forEach(({ setState }) => {
-        setState(SIGNAL_RESET);
-      });
-    },
-    []
-  );
-};
-const createLocalStorageAdapter = (forage) => ({
-  getItem: async (key) => {
-    const serializedValue = forage.getItem(key);
-    if (!serializedValue)
-      return void 0;
-    return JSON.parse(serializedValue);
-  },
-  setItem: async (key, value) => {
-    forage.setItem(key, JSON.stringify(value));
-  }
-});
-const PersistSignalsContext = createContext({
-  resetSignals: () => {
-  }
-});
-const usePersistSignalsContext = () => useContext(PersistSignalsContext);
-const PersistSignals = memo(
-  ({
-    children,
-    signals = [],
-    onReady,
-    adapter = createLocalStorageAdapter(localStorage)
-  }) => {
-    const persistanceRef = useLiveRef(signals);
-    const onReadyRef = useLiveRef(onReady);
-    const adapterRef = useLiveRef(adapter);
-    const resetSignalSubject = useSubject();
-    const resetSignals = useCallback(() => {
-      persistanceRef.current.forEach(({ setValue }) => {
-        setValue(SIGNAL_RESET);
-      });
-      resetSignalSubject.current.next();
-    }, []);
-    const value = useMemo(() => ({ resetSignals }), [resetSignals]);
-    const isHydrated = useObserve(() => {
-      const items = persistanceRef.current;
-      const stream = items.length === 0 ? of(true) : zip(
-        ...items.map(
-          ({ hydrateValue }) => from(hydrateValue({ adapter: adapterRef.current }))
-        )
-      ).pipe(map(() => true));
-      return stream.pipe(
-        tap(() => {
-          if (onReadyRef.current != null)
-            onReadyRef.current();
-        }),
-        catchError((error) => {
-          console.error("Unable to hydrate", error);
-          return EMPTY;
-        })
-      );
-    }, []) ?? false;
-    useSubscribe(
-      () => !isHydrated ? EMPTY : merge(
-        ...persistanceRef.current.map(
-          ({ persistValue, $ }) => (
-            // @todo test the reset
-            merge(
-              resetSignalSubject.current,
-              $.pipe(
-                throttleTime(500, void 0, {
-                  trailing: true,
-                  leading: false
-                })
-              )
-            ).pipe(switchMap(() => from(persistValue({ adapter }))))
-          )
-        )
-      ),
-      [isHydrated, adapter]
-    );
-    return isHydrated ? /* @__PURE__ */ jsx(PersistSignalsContext.Provider, { value, children }) : null;
-  }
-);
-const getNormalizedPersistanceValue = (unknownValue) => {
-  if (unknownValue === null)
-    return void 0;
-  if (typeof unknownValue === "object" && "__key" in unknownValue && unknownValue.__key === "reactjrx_persistance") {
-    return unknownValue;
-  }
-  return void 0;
-};
-function withPersistance(_signal, { version = 0 } = {}) {
-  if (!_signal.options.key) {
-    console.error(
-      "You need to specify a key to use persistance with this signal"
-    );
-  }
-  const hydrateValue = async ({
-    adapter,
-    key = _signal.options.key
-  }) => {
-    if (!key)
-      return;
-    const value = await adapter.getItem(key);
-    const normalizedValue = getNormalizedPersistanceValue(value);
-    if (normalizedValue == null)
-      return;
-    if (normalizedValue.migrationVersion && version > normalizedValue.migrationVersion) {
-      return;
-    }
-    _signal.setState(value.value);
-  };
-  const persistValue = async ({
-    adapter,
-    key = _signal.options.key
-  }) => {
-    if (!key)
-      return;
-    const state = _signal.getValue();
-    const value = {
-      value: state,
-      __key: "reactjrx_persistance",
-      migrationVersion: version
-    };
-    await adapter.setItem(key, value);
-  };
-  return [
-    {
-      hydrateValue,
-      persistValue,
-      setValue: _signal.setState,
-      $: _signal.subject,
-      options: _signal.options
-    },
-    _signal
-  ];
-}
 const normalizeStore = (store) => {
   if (!store || typeof store !== "object") {
     return void 0;
@@ -377,6 +230,107 @@ const createLocalforageAdapter = (forage) => ({
     await forage.setItem(key, JSON.stringify(value));
   }
 });
+const createLocalStorageAdapter = (forage) => ({
+  getItem: async (key) => {
+    const serializedValue = forage.getItem(key);
+    if (!serializedValue)
+      return void 0;
+    return JSON.parse(serializedValue);
+  },
+  setItem: async (key, value) => {
+    forage.setItem(key, 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 = async ({
+  adapter,
+  signal: signal2,
+  version
+}) => {
+  const state = signal2.getValue();
+  const value = {
+    value: state,
+    [IDENTIFIER_PERSISTANCE_KEY]: IDENTIFIER_PERSISTANCE_KEY,
+    migrationVersion: version
+  };
+  await adapter.setItem(signal2.config.key, value);
+};
+const hydrateValueToSignal = ({
+  adapter,
+  version,
+  signal: signal2
+}) => {
+  return from(adapter.getItem(signal2.config.key)).pipe(
+    switchMap((value) => {
+      const normalizedValue = getNormalizedPersistanceValue(value);
+      if (!normalizedValue)
+        return of(value);
+      if (normalizedValue.migrationVersion !== void 0 && version > normalizedValue.migrationVersion) {
+        return of(value);
+      }
+      signal2.setValue(value.value);
+      return of(value);
+    })
+  );
+};
+const usePersistSignals = ({
+  entries = [],
+  onReady,
+  adapter = createLocalStorageAdapter(localStorage)
+}) => {
+  const entriesRef = useLiveRef(entries);
+  const onReadyRef = useLiveRef(onReady);
+  const adapterRef = useLiveRef(adapter);
+  const isHydrated = useObserve(
+    () => {
+      const entries2 = entriesRef.current;
+      const stream = entries2.length === 0 ? of(true) : zip(
+        ...entries2.map(
+          ({ signal: signal2, version }) => hydrateValueToSignal({
+            adapter: adapterRef.current,
+            signal: signal2,
+            version
+          })
+        )
+      ).pipe(map(() => true));
+      return stream.pipe(
+        tap(() => {
+          if (onReadyRef.current != null)
+            onReadyRef.current();
+        }),
+        catchError((error) => {
+          console.error("Unable to hydrate", error);
+          return EMPTY;
+        })
+      );
+    },
+    { defaultValue: false },
+    []
+  );
+  useSubscribe(() => {
+    return !isHydrated ? EMPTY : merge(
+      ...entriesRef.current.map(
+        ({ signal: signal2, version }) => signal2.subject.pipe(
+          throttleTime(500, asyncScheduler, {
+            trailing: true
+          }),
+          switchMap(
+            () => from(
+              persistValue({ adapter: adapterRef.current, signal: signal2, version })
+            )
+          )
+        )
+      )
+    );
+  }, [isHydrated, adapterRef]);
+  return { isHydrated };
+};
 const useUnmountObservable = () => {
   const subject = useSubject({
     onBeforeComplete: () => {
@@ -609,11 +563,8 @@ const ClientEffect = ({
   return null;
 };
 const Provider = memo(
-  ({
-    children,
-    client
-  }) => {
-    const value = useMemo(() => ({ client }), [client]);
+  ({ children, client }) => {
+    const value = useMemo(() => ({ client: client.client }), [client]);
     return /* @__PURE__ */ jsxs(Context.Provider, { value, children: [
       /* @__PURE__ */ jsx(ClientEffect, { client: value.client }),
       children
@@ -1701,9 +1652,15 @@ const createClient = () => {
     ...refetchClient
   };
 };
+class QueryClient {
+  constructor() {
+    __publicField(this, "client");
+    this.client = createClient();
+  }
+}
 export {
-  PersistSignals,
-  Provider as ReactjrxQueryProvider,
+  QueryClient,
+  Provider as QueryClientProvider,
   SIGNAL_RESET,
   createClient,
   createLocalforageAdapter,
@@ -1718,16 +1675,12 @@ export {
   useLiveRef,
   useObserve,
   useObserveCallback,
-  usePersistSignalsContext,
+  usePersistSignals,
   useQuery,
   useQueryClient,
-  useScopeSignals,
-  useSetSignal,
-  useSignal,
   useSignalValue,
   useSubject,
   useSubscribe,
   useSubscribeEffect,
-  useUnmountObservable,
-  withPersistance
+  useUnmountObservable
 };

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

@@ -68,3 +68,7 @@ export declare const createClient: () => {
         start: () => () => void;
     };
 };
+export declare class QueryClient {
+    client: ReturnType<typeof createClient>;
+    constructor();
+}

package/dist/lib/queries/react/Provider.d.ts

@@ -1,11 +1,11 @@
 import { type ReactNode } from "react";
-import { type createClient } from "../client/createClient";
+import { type QueryClient, type createClient } from "../client/createClient";
 export declare const Context: import("react").Context<{
     client: ReturnType<typeof createClient>;
 }>;
 export declare const Provider: import("react").MemoExoticComponent<({ children, client }: {
     children: ReactNode;
-    client: ReturnType<typeof createClient>;
+    client: QueryClient;
 }) => import("react/jsx-runtime").JSX.Element>;
 export declare const useQueryClient: () => {
     pipeQueryResult: <R extends Partial<import("../client/types").QueryResult<T>>, T>({ options$ }: {

package/dist/lib/state/persistance/{createSharedStoreAdapter.d.ts → adapters/createSharedStoreAdapter.d.ts}

@@ -1,4 +1,4 @@
-import { type Adapter } from "./types";
+import { type Adapter } from "../types";
 /**
  * Create an adapter which use one unique store entry to store all
  * state. When using many signals it can help with maintenance to keep things

package/dist/lib/state/persistance/constants.d.ts

@@ -0,0 +1 @@
+export declare const IDENTIFIER_PERSISTANCE_KEY = "__reactjrx";

package/dist/lib/state/persistance/types.d.ts

@@ -1,9 +1,10 @@
+import type { IDENTIFIER_PERSISTANCE_KEY } from "./constants";
 export interface Adapter {
-    getItem: (key: string) => Promise<unknown> | unknown;
-    setItem: (key: string, value: any) => Promise<unknown> | unknown;
+    getItem: (key: string) => Promise<unknown>;
+    setItem: (key: string, value: any) => Promise<unknown>;
 }
 export interface PersistanceEntry {
     value: unknown;
     migrationVersion?: number;
-    __key: "reactjrx_persistance";
+    [IDENTIFIER_PERSISTANCE_KEY]: typeof IDENTIFIER_PERSISTANCE_KEY;
 }

package/dist/lib/state/persistance/usePersistSignals.d.ts

@@ -0,0 +1,12 @@
+import type { Adapter } from "./types";
+import type { Signal } from "../signal";
+export declare const usePersistSignals: ({ entries, onReady, adapter }: {
+    entries?: {
+        version: number;
+        signal: Signal<any, any, string>;
+    }[] | undefined;
+    onReady?: (() => void) | undefined;
+    adapter?: Adapter | undefined;
+}) => {
+    isHydrated: boolean;
+};

package/dist/lib/state/signal.d.ts

@@ -1,18 +1,22 @@
 import type { Observable } from "rxjs";
 import { SIGNAL_RESET } from "./constants";
-type Option<R = undefined> = {
-    key?: string;
-} & (R extends undefined ? {
-    default?: R;
+type WithOptionalDefault<V> = V extends undefined ? {
+    default?: V;
 } : {
-    default: R;
-});
-type SetState<S> = (stateOrUpdater: typeof SIGNAL_RESET | S | ((prev: S) => S)) => void;
-export interface Signal<S, R> {
-    setState: SetState<S>;
+    default: V;
+};
+type WithOptionalKey<V> = V extends undefined ? {
+    key?: V;
+} : {
+    key: V;
+};
+type Config<R = undefined, K = undefined> = WithOptionalKey<K> & WithOptionalDefault<R>;
+type setValue<S> = (stateOrUpdater: typeof SIGNAL_RESET | S | ((prev: S) => S)) => void;
+export interface Signal<S = undefined, R = undefined, K = undefined> {
+    setValue: setValue<S>;
     getValue: () => R;
-    options: Option<S>;
+    config: Config<S, K>;
     subject: Observable<S>;
 }
-export declare function signal<T = undefined>(options: Option<T>): Signal<T, T>;
+export declare function signal<T = undefined, K = undefined>(config: Config<T, K>): Signal<T, T, K>;
 export {};

package/dist/lib/state/useSignalValue.d.ts

@@ -1,2 +1,2 @@
 import { type Signal } from "./signal";
-export declare const useSignalValue: <S>(signal: Signal<S, S>, key?: string) => S;
+export declare const useSignalValue: <S, K>(signal: Signal<S, S, K>, key?: string) => S;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reactjrx",
   "private": false,
-  "version": "1.46.0",
+  "version": "1.48.0",
   "type": "module",
   "files": [
     "dist"

package/dist/lib/state/persistance/PersistSignals.d.ts

@@ -1,12 +0,0 @@
-import { type ReactNode } from "react";
-import type { WithPersistanceReturn } from "./withPersistance";
-import { type Adapter } from "./types";
-export declare const usePersistSignalsContext: () => {
-    resetSignals: () => void;
-};
-export declare const PersistSignals: import("react").MemoExoticComponent<({ children, signals, onReady, adapter }: {
-    children: ReactNode;
-    signals?: WithPersistanceReturn<any>[] | undefined;
-    onReady?: (() => void) | undefined;
-    adapter?: Adapter | undefined;
-}) => import("react/jsx-runtime").JSX.Element | null>;

package/dist/lib/state/persistance/withPersistance.d.ts

@@ -1,18 +0,0 @@
-import type { Signal } from "../signal";
-import { type Adapter } from "./types";
-export interface WithPersistanceReturn<T> {
-    hydrateValue: (params: {
-        adapter: Adapter;
-    }) => Promise<void>;
-    persistValue: (params: {
-        adapter: Adapter;
-    }) => Promise<void>;
-    setValue: Signal<T, T>["setState"];
-    $: Signal<T, T>["subject"];
-    options: {
-        key?: string;
-    };
-}
-export declare function withPersistance<T>(_signal: Signal<T, T>, { version }?: {
-    version?: number;
-}): [WithPersistanceReturn<T>, Signal<T, T>];

package/dist/lib/state/useScopeSignals.d.ts

@@ -1,5 +0,0 @@
-import { type Signal } from "./signal";
-/**
- * Will reset signals when the scope is unmounted
- */
-export declare const useScopeSignals: (signals: Array<Signal<any, any>>) => void;

package/dist/lib/state/useSetSignal.d.ts

@@ -1,2 +0,0 @@
-import { type Signal } from "./signal";
-export declare const useSetSignal: <S, R>(signal: Signal<S, R>) => (stateOrUpdater: typeof import("./constants").SIGNAL_RESET | S | ((prev: S) => S)) => void;

package/dist/lib/state/useSignal.d.ts

@@ -1,2 +0,0 @@
-import { type Signal } from "./signal";
-export declare const useSignal: <S>(signal: Signal<S, S>) => readonly [S, (stateOrUpdater: typeof import("./constants").SIGNAL_RESET | S | ((prev: S) => S)) => void];