react-redux-cache 0.22.1 → 0.22.2

package/dist/types/types.d.ts

@@ -1,206 +1,382 @@
-import type { Actions } from './createActions';
-import type { Selectors } from './createSelectors';
-export type Key = string | number | symbol;
+import type {Actions} from './createActions'
+import type {Selectors} from './createSelectors'
+
+export type Key = string | number | symbol
+
 export type Mutable = {
-    /**
-     * Used only when mutable cache enabled. Always incremented when collection changed by reducer to allow subscribe on changes.
-     * Should not be used for comparing different collections as supposed to be compared only with previously saved changeKey of the same collection.
-     */
-    _changeKey?: number;
-};
-export type Dict<T> = Record<Key, T> & Mutable;
+  /**
+   * Used only when mutable cache enabled. Always incremented when collection changed by reducer to allow subscribe on changes.
+   * Should not be used for comparing different collections as supposed to be compared only with previously saved changeKey of the same collection.
+   */
+  _changeKey?: number
+}
+
+export type Dict<T> = Record<Key, T> & Mutable
+
 export type OptionalPartial<T, K extends keyof T> = Partial<{
-    [A in K]: Partial<T[A]>;
-}> & Omit<T, K>;
+  [A in K]: Partial<T[A]>
+}> &
+  Omit<T, K>
+
 /** Entity changes to be merged to the state. */
 export type EntityChanges<T extends Typenames> = {
-    /** Entities that will be merged with existing. */
-    merge?: PartialEntitiesMap<T>;
-    /** Entities that will replace existing. */
-    replace?: Partial<EntitiesMap<T>>;
-    /** Ids of entities that will be removed. */
-    remove?: EntityIds<T>;
-    /** Alias for `merge` to support normalizr. */
-    entities?: EntityChanges<T>['merge'];
-};
+  /** Entities that will be merged with existing. */
+  merge?: PartialEntitiesMap<T>
+  /** Entities that will replace existing. */
+  replace?: Partial<EntitiesMap<T>>
+  /** Ids of entities that will be removed. */
+  remove?: EntityIds<T>
+  /** Alias for `merge` to support normalizr. */
+  entities?: EntityChanges<T>['merge']
+}
+
 export type Store<S = unknown> = {
-    dispatch: (action: ReturnType<Actions[keyof Actions]>) => unknown;
-    getState: () => S;
-};
+  dispatch: (action: ReturnType<Actions[keyof Actions]>) => unknown
+  getState: () => S
+}
+
 /** Record of typename and its corresponding entity type */
-export type Typenames = Record<string, object>;
+export type Typenames = Record<string, object>
+
 export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
-    /** Used as prefix for actions and in default cacheStateSelector for selecting cache state from store root state. */
-    name: N;
-    /** Cache options. */
-    options: CacheOptions;
-    /** Default options for queries and mutations. */
-    globals: Globals<N, T, QP, QR, MP, MR>;
-    /** Hooks to access and subscribe to the store. Imported from react-redux if not overridden. */
-    storeHooks: {
-        useStore: () => Store;
-        useSelector: <R>(selector: (state: unknown) => R, comparer?: (x: R, y: R) => boolean) => R;
-    };
-    /** Should return cache state from store root state. Default implementation returns `state[name]`. */
-    cacheStateSelector: (state: any) => CacheState<T, QP, QR, MP, MR>;
-    /** Queries. */
-    queries: {
-        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<N, T, QP[QK], QR[QK], QP, QR, MP, MR> : never;
-    };
-    /** Mutations. */
-    mutations: {
-        [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<N, T, MP[MK], MR[MK], QP, QR, MP, MR> : never;
-    };
-};
-export type QueryStateComparer<T extends Typenames, P, R> = (x: QueryState<T, P, R> | undefined, y: QueryState<T, P, R> | undefined) => boolean;
+  /** Used as prefix for actions and in default cacheStateSelector for selecting cache state from store root state. */
+  name: N
+  /** Cache options. */
+  options: CacheOptions
+  /** Default options for queries and mutations. */
+  globals: Globals<N, T, QP, QR, MP, MR>
+  /** Hooks to access and subscribe to the store. Imported from react-redux if not overridden. */
+  storeHooks: {
+    useStore: () => Store
+    useSelector: <R>(selector: (state: unknown) => R, comparer?: (x: R, y: R) => boolean) => R
+  }
+  /** Should return cache state from store root state. Default implementation returns `state[name]`. */
+  cacheStateSelector: (state: any) => CacheState<T, QP, QR, MP, MR>
+  /** Queries. */
+  queries: {
+    [QK in keyof (QP & QR)]: QK extends keyof (QP | QR)
+      ? QueryInfo<N, T, QP[QK], QR[QK], QP, QR, MP, MR>
+      : never
+  }
+  /** Mutations. */
+  mutations: {
+    [MK in keyof (MP & MR)]: MK extends keyof (MP | MR)
+      ? MutationInfo<N, T, MP[MK], MR[MK], QP, QR, MP, MR>
+      : never
+  }
+}
+
+export type QueryStateComparer<T extends Typenames, P, R> = (
+  x: QueryState<T, P, R> | undefined,
+  y: QueryState<T, P, R> | undefined,
+) => boolean
+
 export type Globals<N extends string, T extends Typenames, QP, QR, MP, MR> = {
-    /** Handles errors, not handled by onError from queries and mutations. @Default undefined. */
-    onError?: (error: unknown, key: string, params: unknown, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void;
-    /** Query options. */
-    queries: {
-        /** Determines when useQuery fetch triggers should start fetching. Fetch is performed if function returns true.
-         * Fetch triggers are: 1) mount 2) cache key change 3) skipFetch value change to false.
-         * @Default FetchPolicy.NoCacheOrExpired */
-        fetchPolicy: (expired: boolean, params: unknown, state: QueryState<T, unknown, unknown>, store: Store, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean;
-        /** Disables any fetches when set to true. Triggers fetch when changed to false. @Default false */
-        skipFetch: boolean;
-        /** If set, this value updates expiresAt value of query state when query result is received. @Default undefined */
-        secondsToLive?: number;
-        /** Either comparer function, or array of keys to subscribe by useQuery's useSelector. @Default compares result, loading, params, error. */
-        selectorComparer?: QueryStateComparer<T, unknown, unknown> | (keyof QueryState<T, unknown, unknown>)[];
-    };
-};
+  /** Handles errors, not handled by onError from queries and mutations. @Default undefined. */
+  onError?: (
+    error: unknown,
+    key: string,
+    params: unknown,
+    store: Store,
+    actions: Actions<N, T, QP, QR, MP, MR>,
+    selectors: Selectors<N, T, QP, QR, MP, MR>,
+  ) => void
+  /** Query options. */
+  queries: {
+    /** Determines when useQuery fetch triggers should start fetching. Fetch is performed if function returns true.
+     * Fetch triggers are: 1) mount 2) cache key change 3) skipFetch value change to false.
+     * @Default FetchPolicy.NoCacheOrExpired */
+    fetchPolicy: (
+      expired: boolean,
+      params: unknown,
+      state: QueryState<T, unknown, unknown>,
+      store: Store,
+      selectors: Selectors<N, T, QP, QR, MP, MR>,
+    ) => boolean
+    /** Disables any fetches when set to true. Triggers fetch when changed to false. @Default false */
+    skipFetch: boolean
+    /** If set, this value updates expiresAt value of query state when query result is received. @Default undefined */
+    secondsToLive?: number
+    /** Either comparer function, or array of keys to subscribe by useQuery's useSelector. @Default compares result, loading, params, error. */
+    selectorComparer?: QueryStateComparer<T, unknown, unknown> | (keyof QueryState<T, unknown, unknown>)[]
+  }
+}
+
 export type CacheOptions = {
-    /**
-     * BETA: Optimization that makes state collections mutable.
-     * Subscription to mutable collecitons will work only when subscribed to both collection and its change key - collections
-     * still can be replaced with the new ones instead of mutating e.g. when clearing state.
-     * @Default false
-     * */
-    mutableCollections: boolean;
-    /** Enables additional validation with logging to console.warn. Recommended to enable in dev/testing mode. @Default true in dev mode. */
-    additionalValidation: boolean;
-    /** Enables debug logs. @Default false */
-    logsEnabled: boolean;
-    /**
-     * Enables deep comparison before merging entities to the state.
-     * Re-rendering is a heavier operation than comparison, so disabling it can lead to performance drop.
-     * Makes sense to disable only if merging equal results & entities to the state is a rare case.
-     * @Default true
-     */
-    deepComparisonEnabled: boolean;
-};
+  /**
+   * BETA: Optimization that makes state collections mutable.
+   * Subscription to mutable collecitons will work only when subscribed to both collection and its change key - collections
+   * still can be replaced with the new ones instead of mutating e.g. when clearing state.
+   * @Default false
+   * */
+  mutableCollections: boolean
+  /** Enables additional validation with logging to console.warn. Recommended to enable in dev/testing mode. @Default true in dev mode. */
+  additionalValidation: boolean
+  /** Enables debug logs. @Default false */
+  logsEnabled: boolean
+  /**
+   * Enables deep comparison before merging entities to the state.
+   * Re-rendering is a heavier operation than comparison, so disabling it can lead to performance drop.
+   * Makes sense to disable only if merging equal results & entities to the state is a rare case.
+   * @Default true
+   */
+  deepComparisonEnabled: boolean
+}
+
 export type PartialEntitiesMap<T extends Typenames> = {
-    [K in keyof T]?: Dict<Partial<T[K]>>;
-};
+  [K in keyof T]?: Dict<Partial<T[K]>>
+}
+
 export type EntitiesMap<T extends Typenames> = {
-    [K in keyof T]?: Dict<T[K]>;
-};
+  [K in keyof T]?: Dict<T[K]>
+}
+
 export type EntityIds<T extends Typenames> = {
-    [K in keyof T]?: Key[];
-};
+  [K in keyof T]?: Key[]
+}
+
 export type CacheState<T extends Typenames, QP, QR, MP, MR> = {
-    entities: EntitiesMap<T> & Mutable;
-    queries: {
-        [QK in keyof (QP | QR)]: Dict<QueryState<T, QP[QK], QR[QK]> | undefined>;
-    } & Mutable;
-    mutations: {
-        [MK in keyof (MP | MR)]: MutationState<T, MP[MK], MR[MK]>;
-    } & Mutable;
-};
-export type QueryInfo<N extends string, T extends Typenames = Typenames, P = unknown, R = unknown, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = Partial<Pick<Globals<N, T, QP, QR, MP, MR>['queries'], 'skipFetch' | 'secondsToLive'>> & {
-    query: NormalizedQuery<T, P, R>;
-    /** Determines when useQuery fetch triggers should start fetching. Fetch is performed if function returns true.
-     * Fetch triggers are: 1) mount 2) cache key change 3) skipFetch value change to false.
-     * @Default FetchPolicy.NoCacheOrExpired */
-    fetchPolicy?: (expired: boolean, params: P, queryState: QueryState<T, P, R>, store: Store, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean;
-    /** Merges results before saving to the store. Default implementation is using the latest result. */
-    mergeResults?: (oldResult: R | undefined, response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => R;
-    /**
-     * Cache key is used for storing the query state and for performing a fetch when it changes. Queries with the same cache key share their state.
-     * Default implementation uses `String()` or `JSON.stringify` depending on type.
-     * It is recommended to override it when default implementation is not optimal or when keys in params object can be sorted in random order etc.
-     */
-    getCacheKey?: (params: P) => Key;
-    /** Called after fetch completed either successfully or not. */
-    onCompleted?: (response: NormalizedQueryResponse<T, R> | undefined, error: unknown | undefined, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void;
-    /** Called after fetch finished successfully. */
-    onSuccess?: (response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void;
-    /** Called after fetch finished with error. Should return true if error was handled and does not require global onError handling. */
-    onError?: (error: unknown, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined;
-    /** Either comparer function, or array of keys to subscribe by useQuery's useSelector. Default compares params, result, loading, error. */
-    selectorComparer?: QueryStateComparer<T, P, R> | (keyof QueryState<T, P, R>)[];
-};
+  entities: EntitiesMap<T> & Mutable
+  queries: {
+    [QK in keyof (QP | QR)]: Dict<QueryState<T, QP[QK], QR[QK]> | undefined>
+  } & Mutable
+  mutations: {
+    [MK in keyof (MP | MR)]: MutationState<T, MP[MK], MR[MK]>
+  } & Mutable
+}
+
+export type QueryInfo<
+  N extends string,
+  T extends Typenames = Typenames,
+  P = unknown,
+  R = unknown,
+  QP = unknown,
+  QR = unknown,
+  MP = unknown,
+  MR = unknown,
+> = Partial<Pick<Globals<N, T, QP, QR, MP, MR>['queries'], 'skipFetch' | 'secondsToLive'>> & {
+  query: NormalizedQuery<T, P, R>
+  /** Determines when useQuery fetch triggers should start fetching. Fetch is performed if function returns true.
+   * Fetch triggers are: 1) mount 2) cache key change 3) skipFetch value change to false.
+   * @Default FetchPolicy.NoCacheOrExpired */
+  fetchPolicy?: (
+    expired: boolean,
+    params: P,
+    queryState: QueryState<T, P, R>,
+    store: Store,
+    selectors: Selectors<N, T, QP, QR, MP, MR>,
+  ) => boolean
+  /** Merges results before saving to the store. Default implementation is using the latest result. */
+  mergeResults?: (
+    oldResult: R | undefined,
+    response: NormalizedQueryResponse<T, R>,
+    params: P | undefined,
+    store: Store,
+    actions: Actions<N, T, QP, QR, MP, MR>,
+    selectors: Selectors<N, T, QP, QR, MP, MR>,
+  ) => R
+  /**
+   * Cache key is used for storing the query state and for performing a fetch when it changes. Queries with the same cache key share their state.
+   * Default implementation uses `String()` or `JSON.stringify` depending on type.
+   * It is recommended to override it when default implementation is not optimal or when keys in params object can be sorted in random order etc.
+   */
+  getCacheKey?: (params: P) => Key
+  /** Called after fetch completed either successfully or not. */
+  onCompleted?: (
+    response: NormalizedQueryResponse<T, R> | undefined,
+    error: unknown | undefined,
+    params: P | undefined,
+    store: Store,
+    actions: Actions<N, T, QP, QR, MP, MR>,
+    selectors: Selectors<N, T, QP, QR, MP, MR>,
+  ) => void
+  /** Called after fetch finished successfully. */
+  onSuccess?: (
+    response: NormalizedQueryResponse<T, R>,
+    params: P | undefined,
+    store: Store,
+    actions: Actions<N, T, QP, QR, MP, MR>,
+    selectors: Selectors<N, T, QP, QR, MP, MR>,
+  ) => void
+  /** Called after fetch finished with error. Should return true if error was handled and does not require global onError handling. */
+  onError?: (
+    error: unknown,
+    params: P | undefined,
+    store: Store,
+    actions: Actions<N, T, QP, QR, MP, MR>,
+    selectors: Selectors<N, T, QP, QR, MP, MR>,
+  ) => boolean | void | null | undefined
+  /** Either comparer function, or array of keys to subscribe by useQuery's useSelector. Default compares params, result, loading, error. */
+  selectorComparer?: QueryStateComparer<T, P, R> | (keyof QueryState<T, P, R>)[]
+}
+
 export type Query<P = unknown, R = unknown> = (
-/** Query parameters */
-params: P, 
-/** Store */
-store: Store) => Promise<QueryResponse<R>>;
-export type NormalizedQuery<T extends Typenames = Typenames, P = unknown, R = unknown> = (...args: Parameters<Query<P, R>>) => Promise<NormalizedQueryResponse<T, R>>;
+  /** Query parameters */
+  params: P,
+  /** Store */
+  store: Store,
+) => Promise<QueryResponse<R>>
+
+export type NormalizedQuery<T extends Typenames = Typenames, P = unknown, R = unknown> = (
+  ...args: Parameters<Query<P, R>>
+) => Promise<NormalizedQueryResponse<T, R>>
+
 export type QueryState<T extends Typenames, P, R> = MutationState<T, P, R> & {
-    /**
-     * Timestamp in milliseconds, after which state is considered expired.
-     * Hooks may refetch the query again when component mounts, cache key or skip option change, depending on the fetch policy.
-     * Client query calls also start making fetch if onlyIfExpired argument is truthy.
-     * */
-    expiresAt?: number;
-};
-export type UseQueryOptions<N extends string, T extends Typenames, QK extends keyof (QP & QR), QP, QR, MP, MR> = {
-    query: QK;
-    params: QK extends keyof (QP | QR) ? QP[QK] : never;
-} & Pick<QueryInfo<N, T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never, QP, QR, MP, MR>, 'fetchPolicy' | 'skipFetch' | 'secondsToLive' | 'selectorComparer' | 'mergeResults' | 'onCompleted' | 'onSuccess' | 'onError'>;
-export type QueryOptions<N extends string, T extends Typenames, QP, QR, QK extends keyof (QP & QR), MP, MR> = Pick<UseQueryOptions<N, T, QK, QP, QR, MP, MR>, 'query' | 'params' | 'skipFetch' | 'secondsToLive' | 'mergeResults' | 'onCompleted' | 'onSuccess' | 'onError'> & {
-    /** If set to true, query will run only if it is expired or result not yet cached. */
-    onlyIfExpired?: boolean;
-};
+  /**
+   * Timestamp in milliseconds, after which state is considered expired.
+   * Hooks may refetch the query again when component mounts, cache key or skip option change, depending on the fetch policy.
+   * Client query calls also start making fetch if onlyIfExpired argument is truthy.
+   * */
+  expiresAt?: number
+}
+
+export type UseQueryOptions<
+  N extends string,
+  T extends Typenames,
+  QK extends keyof (QP & QR),
+  QP,
+  QR,
+  MP,
+  MR,
+> = {
+  query: QK
+  params: QK extends keyof (QP | QR) ? QP[QK] : never
+} & Pick<
+  QueryInfo<
+    N,
+    T,
+    QK extends keyof (QP | QR) ? QP[QK] : never,
+    QK extends keyof (QP | QR) ? QR[QK] : never,
+    QP,
+    QR,
+    MP,
+    MR
+  >,
+  | 'fetchPolicy'
+  | 'skipFetch'
+  | 'secondsToLive'
+  | 'selectorComparer'
+  | 'mergeResults'
+  | 'onCompleted'
+  | 'onSuccess'
+  | 'onError'
+>
+
+export type QueryOptions<
+  N extends string,
+  T extends Typenames,
+  QP,
+  QR,
+  QK extends keyof (QP & QR),
+  MP,
+  MR,
+> = Pick<
+  UseQueryOptions<N, T, QK, QP, QR, MP, MR>,
+  | 'query'
+  | 'params'
+  | 'skipFetch'
+  | 'secondsToLive'
+  | 'mergeResults'
+  | 'onCompleted'
+  | 'onSuccess'
+  | 'onError'
+> & {
+  /** If set to true, query will run only if it is expired or result not yet cached. */
+  onlyIfExpired?: boolean
+}
+
 export type QueryResponse<R = unknown> = {
-    result: R;
-    /** If defined, overrides this value in the query state, ignoring `secondsToLive` option. */
-    expiresAt?: number;
-};
-export type NormalizedQueryResponse<T extends Typenames = Typenames, R = unknown> = EntityChanges<T> & QueryResponse<R>;
+  result: R
+  /** If defined, overrides this value in the query state, ignoring `secondsToLive` option. */
+  expiresAt?: number
+}
+
+export type NormalizedQueryResponse<T extends Typenames = Typenames, R = unknown> = EntityChanges<T> &
+  QueryResponse<R>
+
 /** Result is always returned, even if cancelled or finished with error. */
 export type QueryResult<R = unknown> = {
-    error?: unknown;
-    /**
-     * Fetch cancelled reason.
-     * @value loading - already loading. Result of current fetch is returned.
-     * @value not-expired - not expired yet. Current state result is returned.
-     */
-    cancelled?: 'loading' | 'not-expired';
-    result?: R;
-};
-export type MutationInfo<N extends string, T extends Typenames = Typenames, P = unknown, R = unknown, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = Pick<QueryInfo<N, T, P, R, QP, QR, MP, MR>, 'onCompleted' | 'onSuccess' | 'onError'> & {
-    mutation: NormalizedMutation<T, P, R>;
-};
+  error?: unknown
+  /**
+   * Fetch cancelled reason.
+   * @value loading - already loading. Result of current fetch is returned.
+   * @value not-expired - not expired yet. Current state result is returned.
+   */
+  cancelled?: 'loading' | 'not-expired'
+  result?: R
+}
+
+export type MutationInfo<
+  N extends string,
+  T extends Typenames = Typenames,
+  P = unknown,
+  R = unknown,
+  QP = unknown,
+  QR = unknown,
+  MP = unknown,
+  MR = unknown,
+> = Pick<QueryInfo<N, T, P, R, QP, QR, MP, MR>, 'onCompleted' | 'onSuccess' | 'onError'> & {
+  mutation: NormalizedMutation<T, P, R>
+}
+
 export type Mutation<P = unknown, R = unknown> = (
-/** Mutation parameters */
-params: P, 
-/** Store */
-store: Store, 
-/** Signal is aborted for current mutation when the same mutation was called once again. */
-abortSignal: AbortSignal) => Promise<MutationResponse<R>>;
-export type NormalizedMutation<T extends Typenames = Typenames, P = unknown, R = unknown> = (...args: Parameters<Mutation<P, R>>) => Promise<NormalizedMutationResponse<T, R>>;
-export type MutateOptions<N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)> = Pick<MutationInfo<N, T, MK extends keyof (MP | MR) ? MP[MK] : never, MK extends keyof (MP | MR) ? MR[MK] : never, QP, QR, MP, MR>, 'onCompleted' | 'onSuccess' | 'onError'> & {
-    mutation: MK;
-    params: MK extends keyof (MP | MR) ? MP[MK] : never;
-};
+  /** Mutation parameters */
+  params: P,
+  /** Store */
+  store: Store,
+  /** Signal is aborted for current mutation when the same mutation was called once again. */
+  abortSignal: AbortSignal,
+) => Promise<MutationResponse<R>>
+
+export type NormalizedMutation<T extends Typenames = Typenames, P = unknown, R = unknown> = (
+  ...args: Parameters<Mutation<P, R>>
+) => Promise<NormalizedMutationResponse<T, R>>
+
+export type MutateOptions<
+  N extends string,
+  T extends Typenames,
+  QP,
+  QR,
+  MP,
+  MR,
+  MK extends keyof (MP & MR),
+> = Pick<
+  MutationInfo<
+    N,
+    T,
+    MK extends keyof (MP | MR) ? MP[MK] : never,
+    MK extends keyof (MP | MR) ? MR[MK] : never,
+    QP,
+    QR,
+    MP,
+    MR
+  >,
+  'onCompleted' | 'onSuccess' | 'onError'
+> & {
+  mutation: MK
+  params: MK extends keyof (MP | MR) ? MP[MK] : never
+}
+
 export type MutationResponse<R = unknown> = {
-    result?: R;
-};
-export type NormalizedMutationResponse<T extends Typenames = Typenames, R = unknown> = EntityChanges<T> & MutationResponse<R>;
+  result?: R
+}
+
+export type NormalizedMutationResponse<T extends Typenames = Typenames, R = unknown> = EntityChanges<T> &
+  MutationResponse<R>
+
 export type MutationResult<R = unknown> = {
-    error?: unknown;
-    aborted?: true;
-    result?: R;
-};
+  error?: unknown
+  aborted?: true
+  result?: R
+}
+
 export type MutationState<T extends Typenames, P, R> = {
-    /** Set when fetch is currently in progress. */
-    loading?: Promise<NormalizedQueryResponse<T, R>>;
-    /** Result of the latest successfull response. */
-    result?: R;
-    /** Error of the latest response. */
-    error?: Error;
-    /** Parameters of the latest request. */
-    params?: P;
-};
+  /** Set when fetch is currently in progress. */
+  loading?: Promise<NormalizedQueryResponse<T, R>>
+  /** Result of the latest successfull response. */
+  result?: R
+  /** Error of the latest response. */
+  error?: Error
+  /** Parameters of the latest request. */
+  params?: P
+}

package/dist/types/useMutation.d.ts

@@ -1,4 +1,39 @@
-import { Actions } from './createActions';
-import { Selectors } from './createSelectors';
-import { Cache, Key, MutateOptions, MutationState, Store, Typenames } from './types';
-export declare const useMutation: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)>(cache: Pick<Cache<N, T, QP, QR, MP, MR>, "options" | "globals" | "mutations" | "storeHooks">, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, options: Omit<MutateOptions<N, T, QP, QR, MP, MR, MK>, "params">, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<import("./types").MutationResult<MK extends infer T_1 ? T_1 extends MK ? T_1 extends keyof MP & keyof MR ? MR[T_1] : never : never : never>>, MutationState<T, MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
+import {Actions} from './createActions'
+import {Selectors} from './createSelectors'
+import {Cache, Key, MutateOptions, MutationState, Store, Typenames} from './types'
+
+export declare const useMutation: <
+  N extends string,
+  T extends Typenames,
+  QP,
+  QR,
+  MP,
+  MR,
+  MK extends keyof (MP & MR),
+>(
+  cache: Pick<Cache<N, T, QP, QR, MP, MR>, 'options' | 'globals' | 'mutations' | 'storeHooks'>,
+  actions: Actions<N, T, QP, QR, MP, MR>,
+  selectors: Selectors<N, T, QP, QR, MP, MR>,
+  options: Omit<MutateOptions<N, T, QP, QR, MP, MR, MK>, 'params'>,
+  abortControllers: WeakMap<Store, Record<Key, AbortController>>,
+) => readonly [
+  (
+    params: MK extends keyof MP & keyof MR ? MP[MK] : never,
+  ) => Promise<
+    import('./types').MutationResult<
+      MK extends infer T_1
+        ? T_1 extends MK
+          ? T_1 extends keyof MP & keyof MR
+            ? MR[T_1]
+            : never
+          : never
+        : never
+    >
+  >,
+  MutationState<
+    T,
+    MK extends keyof MP & keyof MR ? MP[MK] : never,
+    MK extends keyof MP & keyof MR ? MP[MK] : never
+  >,
+  () => boolean,
+]