reactjrx 4.0.9 → 5.0.0

package/dist/lib/queries/useSwitchMutation$.d.ts

@@ -7,6 +7,15 @@ type SwitchVariables<TVariables> = {
     variables: TVariables;
     abort: AbortSignal;
 };
+/**
+ * Each member of TanStack's result, with `variables` holding the variables
+ * given to `mutate` instead of the `{ variables, abort }` the hook runs with.
+ */
+type WithCallerVariables<TResult, TVariables> = TResult extends {
+    variables: infer TResultVariables;
+} ? Omit<TResult, "variables"> & {
+    variables: TResultVariables extends SwitchVariables<TVariables> ? TVariables : undefined;
+} : never;
 /**
  * Runs a mutation, and cancels the call still running when a new one starts.
  * A cancelled call fails with `SwitchMutationCancelError` and is not retried.
@@ -14,12 +23,11 @@ type SwitchVariables<TVariables> = {
  * ends.
  *
  * The callbacks, the client's defaults included, receive the variables given
- * to `mutate`. A `MutationCache`, `result.variables` and `useMutationState`
- * see the `{ variables, abort }` the hook runs the mutation with.
+ * to `mutate`, and `result.variables` holds them. A `MutationCache` and
+ * `useMutationState` see the `{ variables, abort }` the hook runs the
+ * mutation with.
  */
-export declare function useSwitchMutation$<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>({ mutationFn, ...options }: UseMutation$Options<TData | null, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): {
-    mutate: (variables: TVariables) => void;
-    mutateAsync: (variables: TVariables) => Promise<TData | null>;
+export declare function useSwitchMutation$<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>({ mutationFn, ...options }: UseMutation$Options<TData | null, TError, TVariables, TOnMutateResult>, queryClient?: QueryClient): WithCallerVariables<{
     state$: import('rxjs').BehaviorSubject<Pick<import('@tanstack/react-query').UseMutationResult<TData | null, TError, SwitchVariables<TVariables>, TOnMutateResult>, "status" | "isPending" | "isError" | "isSuccess" | "isIdle">>;
     data: undefined;
     variables: undefined;
@@ -36,8 +44,6 @@ export declare function useSwitchMutation$<TData = unknown, TError = DefaultErro
     isPaused: boolean;
     submittedAt: number;
 } | {
-    mutate: (variables: TVariables) => void;
-    mutateAsync: (variables: TVariables) => Promise<TData | null>;
     state$: import('rxjs').BehaviorSubject<Pick<import('@tanstack/react-query').UseMutationResult<TData | null, TError, SwitchVariables<TVariables>, TOnMutateResult>, "status" | "isPending" | "isError" | "isSuccess" | "isIdle">>;
     data: undefined;
     variables: SwitchVariables<TVariables>;
@@ -54,8 +60,6 @@ export declare function useSwitchMutation$<TData = unknown, TError = DefaultErro
     isPaused: boolean;
     submittedAt: number;
 } | {
-    mutate: (variables: TVariables) => void;
-    mutateAsync: (variables: TVariables) => Promise<TData | null>;
     state$: import('rxjs').BehaviorSubject<Pick<import('@tanstack/react-query').UseMutationResult<TData | null, TError, SwitchVariables<TVariables>, TOnMutateResult>, "status" | "isPending" | "isError" | "isSuccess" | "isIdle">>;
     data: undefined;
     error: TError;
@@ -72,8 +76,6 @@ export declare function useSwitchMutation$<TData = unknown, TError = DefaultErro
     isPaused: boolean;
     submittedAt: number;
 } | {
-    mutate: (variables: TVariables) => void;
-    mutateAsync: (variables: TVariables) => Promise<TData | null>;
     state$: import('rxjs').BehaviorSubject<Pick<import('@tanstack/react-query').UseMutationResult<TData | null, TError, SwitchVariables<TVariables>, TOnMutateResult>, "status" | "isPending" | "isError" | "isSuccess" | "isIdle">>;
     data: TData | null;
     error: null;
@@ -89,5 +91,8 @@ export declare function useSwitchMutation$<TData = unknown, TError = DefaultErro
     failureReason: TError | null;
     isPaused: boolean;
     submittedAt: number;
+}, TVariables> & {
+    mutate: (variables: TVariables) => void;
+    mutateAsync: (variables: TVariables) => Promise<TData | null>;
 };
 export {};

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

@@ -53,6 +53,5 @@ export declare function signal<K extends string>(config: {
 }): Signal<undefined, K>;
 export declare function virtualSignal<T>(config: {
     default: T;
-    key?: string;
 }): VirtualSignal<T>;
 export {};

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

@@ -1,13 +1,9 @@
-import { BehaviorSubject } from 'rxjs';
 import { Signal, VirtualSignal } from './Signal';
 export declare class SignalContext {
     /**
-     * items only get added as they are created. The only time we should cleanup
-     * are on context destroy. This is to ensure later re-use of virtual signals
-     * return the same persisted state.
+     * Signals are only added, as they are created, so a virtual signal used
+     * again in the same context gets the same signal and its state.
      */
-    signals: BehaviorSubject<Map<VirtualSignal<unknown>, Signal<any, undefined>>>;
-    isDestroyed: boolean;
+    private readonly signals;
     getOrCreateSignal<T>(virtualSignal: VirtualSignal<T>): Signal<T>;
-    destroy(): void;
 }

package/dist/lib/state/persistence/adapters/Adapter.d.ts

@@ -1,6 +1,7 @@
+/**
+ * Where the persistence reads and writes the values of its signals.
+ */
 export interface Adapter {
     getItem: (key: string) => Promise<unknown>;
     setItem: (key: string, value: any) => Promise<unknown>;
-    removeItem: (key: string) => Promise<unknown>;
-    clear: () => Promise<unknown>;
 }

package/dist/lib/state/persistence/adapters/MockAdapter.d.ts

@@ -9,6 +9,4 @@ export declare class MockAdapter implements Adapter {
     });
     getItem(key: string): Promise<any>;
     setItem(_: string, __: any): Promise<unknown>;
-    removeItem(_: string): Promise<unknown>;
-    clear(): Promise<unknown>;
 }

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

@@ -1,5 +1 @@
 export declare const IDENTIFIER_PERSISTENCE_KEY = "__reactjrx";
-/**
- * What hydration emits when the adapter holds nothing usable for a signal.
- */
-export declare const NOTHING_STORED: unique symbol;

package/dist/lib/state/persistence/helpers.d.ts

@@ -1,20 +1,28 @@
-import { Observable } from 'rxjs';
 import { Adapter } from './adapters/Adapter';
 import { SignalPersistenceConfig } from './types';
 export declare const persistValue: ({ adapter, config, }: {
     adapter: Adapter;
     config: SignalPersistenceConfig<any>;
-}) => Observable<unknown>;
+}) => import('rxjs').Observable<unknown>;
 /**
- * Emits the value the signal was hydrated with, or `NOTHING_STORED` when
- * nothing usable is stored.
+ * What the adapter holds for an entry, as the signal's value:
+ * - `missing`: nothing usable, or a value of an older version that the entry
+ *   has no `hydrate` to migrate;
+ * - `unreadable`: a value that `hydrate` threw on;
+ * - `migrated`: a value of an older version, migrated by `hydrate`, which the
+ *   adapter does not hold yet;
+ * - `current`: a value of the entry's version or newer, through `hydrate`
+ *   when the entry has one.
  */
-export declare function hydrateValueToSignal({ adapter, config, resetToDefault, }: {
-    adapter: Adapter;
-    config: SignalPersistenceConfig<any>;
-    /**
-     * When nothing usable is stored, reset the signal to its default instead of
-     * leaving its current value in place.
-     */
-    resetToDefault?: boolean;
-}): Observable<unknown>;
+export type StoredState = {
+    type: "missing";
+} | {
+    type: "unreadable";
+} | {
+    type: "migrated";
+    value: unknown;
+} | {
+    type: "current";
+    value: unknown;
+};
+export declare const readStoredState: (stored: unknown, { hydrate, signal, version }: SignalPersistenceConfig<any>) => StoredState;

package/dist/lib/state/persistence/persistSignals.d.ts

@@ -13,9 +13,9 @@ type Entry = SignalPersistenceConfig<AnySignal>;
  * - a removed signal stops being persisted, after its pending value is saved.
  *
  * Emits `{ type: "hydrated" }` once, the first time every entry added so far
- * has been hydrated (right away for an empty list). An entry that fails to
- * hydrate is logged and never persisted, and holds back that emission until
- * it is removed.
+ * has been hydrated (right away for an empty list). An entry whose adapter
+ * fails to read it is logged and never persisted, and holds back that
+ * emission until it is removed.
  */
 export declare function persistSignals({ entries$, onHydrated, adapter, resetToDefault, }: {
     entries$: Observable<Entry[]>;

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

@@ -15,11 +15,18 @@ export interface SignalPersistenceConfig<S extends Signal<any, string>> {
     version: number;
     signal: S;
     /**
-     * Called with the stored value when the signal is hydrated from it. The
-     * value is `undefined` when the signal was saved holding `undefined`.
+     * Turns a stored value into the signal's value, given the `version` it was
+     * stored with. It also runs for a value stored with an older version, to
+     * migrate it: the result is then saved with this entry's version. Without
+     * `hydrate`, a value stored with an older version is discarded.
+     *
+     * The value is `unknown`, since the storage can hold any shape, and it is
+     * `undefined` when the signal was saved holding `undefined`. If `hydrate`
+     * throws, the error is logged and the entry hydrates as if nothing usable
+     * were stored, but the storage keeps the value until the signal changes.
      */
     hydrate?: (params: {
         version: number;
-        value: SignalValue<S>;
+        value: unknown;
     }) => SignalValue<S>;
 }

package/dist/lib/state/react/SignalContextProvider.d.ts

@@ -1,9 +1,7 @@
-import { VirtualSignal } from '../Signal';
-import { SignalContext } from '../SignalContext';
-export type SignalContextType = SignalContext;
-export declare const SignalReactContext: import('react').Context<SignalContext>;
-export declare const SignalContextProvider: import('react').MemoExoticComponent<({ children }: {
+/**
+ * Holds the signals of the virtual signals used under it, for as long as it
+ * is mounted. They never complete.
+ */
+export declare const SignalContextProvider: import('react').MemoExoticComponent<({ children, }: {
     children: React.ReactNode;
 }) => import('react').JSX.Element>;
-export declare const useSignalContext: () => SignalContext;
-export declare const useMakeOrRetrieveSignal: (virtualSignal?: VirtualSignal<unknown>) => import('../Signal').Signal<unknown, undefined> | undefined;

package/dist/lib/state/react/SignalReactContext.d.ts

@@ -0,0 +1,2 @@
+import { SignalContext } from '../SignalContext';
+export declare const SignalReactContext: import('react').Context<SignalContext | undefined>;

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

@@ -23,13 +23,14 @@ export declare function usePersistSignals({ entries, onHydrated, adapter, }: {
     /**
      * Passing a new adapter reference starts over: pending values are saved to
      * the previous adapter, then every entry takes the value stored in the new
-     * one. When nothing is stored, or only an older version, the entry goes
-     * back to its default once the hook has had two different adapters, so it
-     * never carries another adapter's value over (another profile's, for
-     * example). Before that, including when the same adapter comes back after
-     * a gap without adapter, it keeps its current value. Adapters are compared
-     * by reference: a new object for the same storage counts as a different
-     * adapter. Use a stable reference to avoid infinite loop.
+     * one. When nothing is stored, or only an older version that the entry has
+     * no `hydrate` for, the entry goes back to its default once the hook has
+     * had two different adapters, so it never carries another adapter's value
+     * over (another profile's, for example). Before that, including when the
+     * same adapter comes back after a gap without adapter, it keeps its current
+     * value. Adapters are compared by reference: a new object for the same
+     * storage counts as a different adapter. Use a stable reference to avoid
+     * infinite loop.
      */
     adapter?: Adapter;
 }): {

package/dist/lib/state/react/useSignalReference.d.ts

@@ -1,2 +1,6 @@
 import { Signal, VirtualSignal } from '../Signal';
+/**
+ * The signal itself, or the signal that the SignalContextProvider above holds
+ * for a virtual signal. Throws for a virtual signal outside a provider.
+ */
 export declare function useSignalReference<T>(signal: Signal<T> | VirtualSignal<T>): Signal<T>;

package/package.json

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