react-redux-cache 0.10.0 → 0.12.0-rc.0

package/README.md

@@ -41,13 +41,12 @@ Examples of states, generated by cache reducer from `/example` project:
     queries: {
       // each query has its own map of query states, stored by cache key, which is generated from query params
       getUser: {
-        "2": {loading: false, result: 2, params: 2, expiresAt: 1727217298025},
+        "2": {result: 2, params: 2, expiresAt: 1727217298025},
         "3": {loading: true, params: 3}
       },
       getUsers: {
         // example of paginated state under custom cache key
         "all-pages": {
-          loading: false,
           result: {items: [0,1,2], page: 1},
           params: {page: 1}
         }
@@ -56,7 +55,6 @@ Examples of states, generated by cache reducer from `/example` project:
     mutations: {
       // each mutation has its own state as well
       updateUser: {
-        loading: false,
         result: 1,
         params: {id: 1, name: "User 1 *"}
       } 
@@ -78,7 +76,6 @@ Examples of states, generated by cache reducer from `/example` project:
       // each query has its own map of query states, stored by cache key, which is generated from query params
       getUser: {
         "2": {
-          loading: false,
           result: {id: 2, bank: {id: "2", name: "Bank 2"}, name: "User 2"},
           params: 2,
           expiresAt: 1727217298025
@@ -88,7 +85,6 @@ Examples of states, generated by cache reducer from `/example` project:
       getUsers: {
         // example of paginated state under custom cache key
         "all-pages": {
-          loading: false,
           result: {
             items: [
               {id: 0, bank: {id: "0", name: "Bank 0"}, name: "User 0 *"},
@@ -104,7 +100,6 @@ Examples of states, generated by cache reducer from `/example` project:
     mutations: {
       // each mutation has its own state as well
       updateUser: {
-        loading: false,
         result: {id: 1, bank: {id: "1", name: "Bank 1"}, name: "User 1 *"},
         params: {id: 1, name: "User 1 *"}
       } 
@@ -212,7 +207,7 @@ Perfect implementation is when the backend already returns normalized data.
 
 // Example of query with normalization (recommended)
 
-export const getUser = async (id) => {
+export const getUser = (async (id) => {
   // Result can be get by any way - fetch, axios etc, even with database connection.
   // There is no limitation here.
   const response = await ...
@@ -220,24 +215,24 @@ export const getUser = async (id) => {
   // In this example normalizr package is used, but it is not necessary.
   return normalize(response, getUserSchema)
   // satisfies keyword is used here for proper typing of params and returned value.
-} satisfies Query<number, CacheTypenames>
+}) satisfies NormalizedQuery<CacheTypenames, number>
 
 // Example of query without normalization (not recommended), with selecting access token from the store
 
-export const getBank = (id, {getState}) => {
+export const getBank = (async (id, {getState}) => {
   const token = tokenSelector(getState())
   const result: Bank = ...
   return {result} // result is bank object, no entities passed
-} satisfies Query<string>
+}) satisfies Query<string>
 
 // Example of mutation with normalization
 
-export const removeUser = async (id, _, abortSignal) => {
+export const removeUser = (async (id, _, abortSignal) => {
   await ...
   return {
     remove: { users: [id] },
   }
-} satisfies Query<number, CacheTypenames>
+}) satisfies NormalizedQuery<CacheTypenames, number>
 ```
 
 ### Usage

package/dist/createActions.d.ts

@@ -3,7 +3,7 @@ export type ActionMap<N extends string, T extends Typenames, QP, QR, MP, MR> = R
 export declare const createActions: <N extends string, T extends Typenames, QP, QR, MP, MR>(name: N) => {
     /** Updates query state, and optionally merges entity changes in a single action. */
     updateQueryStateAndEntities: {
-        <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryState<QP[K], QR[K]>> | undefined, entityChanges?: EntityChanges<T> | undefined): {
+        <K extends keyof (QP | QR)>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryState<QP[K], QR[K]>>, entityChanges?: EntityChanges<T>): {
             type: `@rrc/${N}/updateQueryStateAndEntities`;
             queryKey: K;
             queryCacheKey: Key;
@@ -14,10 +14,10 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
     };
     /** Updates mutation state, and optionally merges entity changes in a single action. */
     updateMutationStateAndEntities: {
-        <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined, entityChanges?: EntityChanges<T> | undefined): {
+        <K extends keyof (MP | MR)>(mutationKey: K, state?: Partial<MutationState<MP[K], MR[K]>>, entityChanges?: EntityChanges<T>): {
             type: `@rrc/${N}/updateMutationStateAndEntities`;
-            mutationKey: K_1;
-            state: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined;
+            mutationKey: K;
+            state: Partial<MutationState<MP[K], MR[K]>> | undefined;
             entityChanges: EntityChanges<T> | undefined;
         };
         type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -32,22 +32,22 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
     };
     /** Invalidates query states. */
     invalidateQuery: {
-        <K_2 extends keyof QP & keyof QR>(queries: {
+        <K extends keyof (QP | QR)>(queries: {
             /** Query key */
-            query: K_2;
+            query: K;
             /** Query cache key */
-            cacheKey?: Key | undefined;
+            cacheKey?: Key;
             /** Unix timestamp at which query expires. Is set to the query state. @default Date.now() */
-            expiresAt?: number | undefined;
+            expiresAt?: number;
         }[]): {
             type: `@rrc/${N}/invalidateQuery`;
             queries: {
                 /** Query key */
-                query: K_2;
+                query: K;
                 /** Query cache key */
-                cacheKey?: Key | undefined;
+                cacheKey?: Key;
                 /** Unix timestamp at which query expires. Is set to the query state. @default Date.now() */
-                expiresAt?: number | undefined;
+                expiresAt?: number;
             }[];
         };
         type: `@rrc/${N}/invalidateQuery`;
@@ -55,27 +55,27 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
     /** Clear states for provided query keys and cache keys.
      * If cache key for query key is not provided, the whole state for query key is cleared. */
     clearQueryState: {
-        <K_3 extends keyof QP & keyof QR>(queries: {
+        <K extends keyof (QP | QR)>(queries: {
             /** Query key */
-            query: K_3;
+            query: K;
             /** Query cache key */
-            cacheKey?: Key | undefined;
+            cacheKey?: Key;
         }[]): {
             type: `@rrc/${N}/clearQueryState`;
             queries: {
                 /** Query key */
-                query: K_3;
+                query: K;
                 /** Query cache key */
-                cacheKey?: Key | undefined;
+                cacheKey?: Key;
             }[];
         };
         type: `@rrc/${N}/clearQueryState`;
     };
     /** Clear states for provided mutation keys. */
     clearMutationState: {
-        <K_4 extends keyof MP & keyof MR>(mutationKeys: K_4[]): {
+        <K extends keyof (MP | MR)>(mutationKeys: K[]): {
             type: `@rrc/${N}/clearMutationState`;
-            mutationKeys: K_4[];
+            mutationKeys: K[];
         };
         type: `@rrc/${N}/clearMutationState`;
     };

package/dist/createCache.d.ts

@@ -11,14 +11,14 @@ import { applyEntityChanges } from './utilsAndConstants';
  * })
  */
 export declare const withTypenames: <T extends Typenames = Typenames>() => {
-    createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, T, QP, QR, MP, MR>, "queries" | "options" | "mutations" | "cacheStateSelector" | "globals">) => {
+    createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, T, QP, QR, MP, MR>, "options" | "queries" | "mutations" | "cacheStateSelector" | "globals">) => {
         /** Keeps all options, passed while creating the cache. */
         cache: Cache<N, T, QP, QR, MP, MR>;
         /** Reducer of the cache, should be added to redux store. */
         reducer: (state: {
             entities: import("./types").EntitiesMap<T>;
-            queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
-            mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: MutationState<MP[MK], MR[MK]>; } : never;
+            queries: { [QK in keyof (QP | QR)]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; };
+            mutations: { [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>; };
         } | undefined, action: {
             type: `@rrc/${N}/updateQueryStateAndEntities`;
             queryKey: keyof QP & keyof QR;
@@ -37,22 +37,22 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
             type: `@rrc/${N}/invalidateQuery`;
             queries: {
                 query: keyof QP & keyof QR;
-                cacheKey?: Key | undefined;
-                expiresAt?: number | undefined;
+                cacheKey?: Key;
+                expiresAt?: number;
             }[];
         } | {
             type: `@rrc/${N}/clearQueryState`;
             queries: {
                 query: keyof QP & keyof QR;
-                cacheKey?: Key | undefined;
+                cacheKey?: Key;
             }[];
         } | {
             type: `@rrc/${N}/clearMutationState`;
             mutationKeys: (keyof MP & keyof MR)[];
         }) => {
             entities: import("./types").EntitiesMap<T>;
-            queries: QP | QR extends infer T_3 ? { [QK in keyof T_3]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
-            mutations: MP | MR extends infer T_4 ? { [MK in keyof T_4]: MutationState<MP[MK], MR[MK]>; } : never;
+            queries: { [QK in keyof (QP | QR)]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; };
+            mutations: { [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>; };
         };
         actions: {
             updateQueryStateAndEntities: {
@@ -66,10 +66,10 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
                 type: `@rrc/${N}/updateQueryStateAndEntities`;
             };
             updateMutationStateAndEntities: {
-                <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
+                <K extends keyof MP & keyof MR>(mutationKey: K, state?: Partial<MutationState<MP[K], MR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
                     type: `@rrc/${N}/updateMutationStateAndEntities`;
-                    mutationKey: K_1;
-                    state: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined;
+                    mutationKey: K;
+                    state: Partial<MutationState<MP[K], MR[K]>> | undefined;
                     entityChanges: import("./types").EntityChanges<T> | undefined;
                 };
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -82,90 +82,90 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
                 type: `@rrc/${N}/mergeEntityChanges`;
             };
             invalidateQuery: {
-                <K_2 extends keyof QP & keyof QR>(queries: {
-                    query: K_2;
-                    cacheKey?: Key | undefined;
-                    expiresAt?: number | undefined;
+                <K extends keyof QP & keyof QR>(queries: {
+                    query: K;
+                    cacheKey?: Key;
+                    expiresAt?: number;
                 }[]): {
                     type: `@rrc/${N}/invalidateQuery`;
                     queries: {
-                        query: K_2;
-                        cacheKey?: Key | undefined;
-                        expiresAt?: number | undefined;
+                        query: K;
+                        cacheKey?: Key;
+                        expiresAt?: number;
                     }[];
                 };
                 type: `@rrc/${N}/invalidateQuery`;
             };
             clearQueryState: {
-                <K_3 extends keyof QP & keyof QR>(queries: {
-                    query: K_3;
-                    cacheKey?: Key | undefined;
+                <K extends keyof QP & keyof QR>(queries: {
+                    query: K;
+                    cacheKey?: Key;
                 }[]): {
                     type: `@rrc/${N}/clearQueryState`;
                     queries: {
-                        query: K_3;
-                        cacheKey?: Key | undefined;
+                        query: K;
+                        cacheKey?: Key;
                     }[];
                 };
                 type: `@rrc/${N}/clearQueryState`;
             };
             clearMutationState: {
-                <K_4 extends keyof MP & keyof MR>(mutationKeys: K_4[]): {
+                <K extends keyof MP & keyof MR>(mutationKeys: K[]): {
                     type: `@rrc/${N}/clearMutationState`;
-                    mutationKeys: K_4[];
+                    mutationKeys: K[];
                 };
                 type: `@rrc/${N}/clearMutationState`;
             };
         };
         selectors: {
             /** Selects query state. */
-            selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => QueryState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>;
+            selectQueryState: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => QueryState<QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never>;
             /** Selects query latest result. */
-            selectQueryResult: <QK_2 extends keyof QP | keyof QR>(state: unknown, query: QK_2, cacheKey: Key) => (QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never) | undefined;
+            selectQueryResult: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => (QK extends keyof QP & keyof QR ? QR[QK] : never) | undefined;
             /** Selects query loading state. */
-            selectQueryLoading: <QK_3 extends keyof QP | keyof QR>(state: unknown, query: QK_3, cacheKey: Key) => boolean;
+            selectQueryLoading: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => boolean;
             /** Selects query latest error. */
-            selectQueryError: <QK_4 extends keyof QP | keyof QR>(state: unknown, query: QK_4, cacheKey: Key) => Error | undefined;
+            selectQueryError: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => Error | undefined;
             /** Selects query latest params. */
-            selectQueryParams: <QK_5 extends keyof QP | keyof QR>(state: unknown, query: QK_5, cacheKey: Key) => (QK_5 extends keyof QP & keyof QR ? QP[QK_5] : never) | undefined;
+            selectQueryParams: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => (QK extends keyof QP & keyof QR ? QP[QK] : never) | undefined;
             /** Selects query latest expiresAt. */
-            selectQueryExpiresAt: <QK_6 extends keyof QP | keyof QR>(state: unknown, query: QK_6, cacheKey: Key) => number | undefined;
+            selectQueryExpiresAt: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => number | undefined;
             /** Selects mutation state. */
-            selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => MutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never, MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>;
+            selectMutationState: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => MutationState<MK extends keyof (MP | MR) ? MP[MK] : never, MK extends keyof (MP | MR) ? MR[MK] : never>;
             /** Selects mutation latest result. */
-            selectMutationResult: <MK_2 extends keyof MP | keyof MR>(state: unknown, mutation: MK_2) => (MK_2 extends keyof MP & keyof MR ? MR[MK_2] : never) | undefined;
+            selectMutationResult: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => (MK extends keyof MP & keyof MR ? MR[MK] : never) | undefined;
             /** Selects mutation loading state. */
-            selectMutationLoading: <MK_3 extends keyof MP | keyof MR>(state: unknown, mutation: MK_3) => boolean;
+            selectMutationLoading: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => boolean;
             /** Selects mutation latest error. */
-            selectMutationError: <MK_4 extends keyof MP | keyof MR>(state: unknown, mutation: MK_4) => Error | undefined;
+            selectMutationError: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => Error | undefined;
             /** Selects mutation latest params. */
-            selectMutationParams: <MK_5 extends keyof MP | keyof MR>(state: unknown, mutation: MK_5) => (MK_5 extends keyof MP & keyof MR ? MP[MK_5] : never) | undefined;
+            selectMutationParams: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => (MK extends keyof MP & keyof MR ? MP[MK] : never) | undefined;
             /** Selects entity by id and typename. */
             selectEntityById: <TN extends keyof T>(state: unknown, id: Key | null | undefined, typename: TN) => T[TN] | undefined;
             /** Selects all entities. */
             selectEntities: (state: unknown) => import("./types").EntitiesMap<T>;
             /** Selects all entities of provided typename. */
-            selectEntitiesByTypename: <TN_1 extends keyof T>(state: unknown, typename: TN_1) => import("./types").EntitiesMap<T>[TN_1];
+            selectEntitiesByTypename: <TN extends keyof T>(state: unknown, typename: TN) => import("./types").EntitiesMap<T>[TN];
         };
         hooks: {
             /** Returns client object with query and mutate functions. */
             useClient: () => {
-                query: <QK_7 extends keyof QP | keyof QR>(options: QueryOptions<T, QP, QR, QK_7>) => Promise<QueryResult<QK_7 extends keyof QP & keyof QR ? QR[QK_7] : never>>;
-                mutate: <MK_6 extends keyof MP | keyof MR>(options: MutateOptions<T, MP, MR, MK_6>) => Promise<MutationResult<MK_6 extends keyof MP & keyof MR ? MR[MK_6] : never>>;
+                query: <QK extends keyof (QP & QR)>(options: QueryOptions<T, QP, QR, QK>) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;
+                mutate: <MK extends keyof (MP & MR)>(options: MutateOptions<T, MP, MR, MK>) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;
             };
             /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
-            useQuery: <QK_8 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, QK_8>) => readonly [Omit<QueryState<QK_8 extends keyof QP & keyof QR ? QP[QK_8] : never, QK_8 extends keyof QP & keyof QR ? QR[QK_8] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<T, QP, QR, QK_8>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK_8 extends infer T_5 ? T_5 extends QK_8 ? T_5 extends keyof QP & keyof QR ? QR[T_5] : never : never : never>>];
+            useQuery: <QK extends keyof (QP & QR)>(options: Parameters<typeof useQuery<N, T, QP, QR, MP, MR, QK>>[2]) => readonly [Omit<QueryState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<T, QP, QR, QK>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK extends infer T_1 ? T_1 extends QK ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];
             /** Subscribes to provided mutation state and provides mutate function. */
-            useMutation: <MK_7 extends keyof MP | keyof MR>(options: Omit<MutateOptions<T, MP, MR, MK_7>, "params">) => readonly [(params: MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never) => Promise<MutationResult<MK_7 extends infer T_6 ? T_6 extends MK_7 ? T_6 extends keyof MP & keyof MR ? MR[T_6] : never : never : never>>, MutationState<MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never, MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never>, () => boolean];
+            useMutation: <MK extends keyof (MP & MR)>(options: Parameters<typeof useMutation<N, T, MP, MR, MK>>[2]) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<MutationResult<MK extends infer T_1 ? T_1 extends MK ? T_1 extends keyof MP & keyof MR ? MR[T_1] : never : never : never>>, MutationState<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
             /** useSelector + selectEntityById. */
-            useSelectEntityById: <TN_2 extends keyof T>(id: Key | null | undefined, typename: TN_2) => T[TN_2] | undefined;
+            useSelectEntityById: <TN extends keyof T>(id: Key | null | undefined, typename: TN) => T[TN] | undefined;
         };
         utils: {
             /**
              * Apply changes to the entities map.
              * @return `undefined` if nothing to change, otherwise new entities map with applied changes.
              */
-            applyEntityChanges: (entities: import("./types").EntitiesMap<T>, changes: import("./types").EntityChanges<T>) => import("./types").EntitiesMap<T> | undefined;
+            applyEntityChanges: (entities: Parameters<typeof applyEntityChanges<T>>[0], changes: Parameters<typeof applyEntityChanges<T>>[1]) => import("./types").EntitiesMap<T> | undefined;
         };
     };
 };
@@ -178,8 +178,8 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
     /** Reducer of the cache, should be added to redux store. */
     reducer: (state: {
         entities: import("./types").EntitiesMap<Typenames>;
-        queries: QP | QR extends infer T ? { [QK in keyof T]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
-        mutations: MP | MR extends infer T_1 ? { [MK in keyof T_1]: MutationState<MP[MK], MR[MK]>; } : never;
+        queries: { [QK in keyof (QP | QR)]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; };
+        mutations: { [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>; };
     } | undefined, action: {
         type: `@rrc/${N}/updateQueryStateAndEntities`;
         queryKey: keyof QP & keyof QR;
@@ -198,22 +198,22 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
         type: `@rrc/${N}/invalidateQuery`;
         queries: {
             query: keyof QP & keyof QR;
-            cacheKey?: Key | undefined;
-            expiresAt?: number | undefined;
+            cacheKey?: Key;
+            expiresAt?: number;
         }[];
     } | {
         type: `@rrc/${N}/clearQueryState`;
         queries: {
             query: keyof QP & keyof QR;
-            cacheKey?: Key | undefined;
+            cacheKey?: Key;
         }[];
     } | {
         type: `@rrc/${N}/clearMutationState`;
         mutationKeys: (keyof MP & keyof MR)[];
     }) => {
         entities: import("./types").EntitiesMap<Typenames>;
-        queries: QP | QR extends infer T_2 ? { [QK in keyof T_2]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
-        mutations: MP | MR extends infer T_3 ? { [MK in keyof T_3]: MutationState<MP[MK], MR[MK]>; } : never;
+        queries: { [QK in keyof (QP | QR)]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; };
+        mutations: { [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>; };
     };
     actions: {
         updateQueryStateAndEntities: {
@@ -227,10 +227,10 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
             type: `@rrc/${N}/updateQueryStateAndEntities`;
         };
         updateMutationStateAndEntities: {
-            <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined, entityChanges?: import("./types").EntityChanges<Typenames> | undefined): {
+            <K extends keyof MP & keyof MR>(mutationKey: K, state?: Partial<MutationState<MP[K], MR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<Typenames> | undefined): {
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
-                mutationKey: K_1;
-                state: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined;
+                mutationKey: K;
+                state: Partial<MutationState<MP[K], MR[K]>> | undefined;
                 entityChanges: import("./types").EntityChanges<Typenames> | undefined;
             };
             type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -243,83 +243,83 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
             type: `@rrc/${N}/mergeEntityChanges`;
         };
         invalidateQuery: {
-            <K_2 extends keyof QP & keyof QR>(queries: {
-                query: K_2;
-                cacheKey?: Key | undefined;
-                expiresAt?: number | undefined;
+            <K extends keyof QP & keyof QR>(queries: {
+                query: K;
+                cacheKey?: Key;
+                expiresAt?: number;
             }[]): {
                 type: `@rrc/${N}/invalidateQuery`;
                 queries: {
-                    query: K_2;
-                    cacheKey?: Key | undefined;
-                    expiresAt?: number | undefined;
+                    query: K;
+                    cacheKey?: Key;
+                    expiresAt?: number;
                 }[];
             };
             type: `@rrc/${N}/invalidateQuery`;
         };
         clearQueryState: {
-            <K_3 extends keyof QP & keyof QR>(queries: {
-                query: K_3;
-                cacheKey?: Key | undefined;
+            <K extends keyof QP & keyof QR>(queries: {
+                query: K;
+                cacheKey?: Key;
             }[]): {
                 type: `@rrc/${N}/clearQueryState`;
                 queries: {
-                    query: K_3;
-                    cacheKey?: Key | undefined;
+                    query: K;
+                    cacheKey?: Key;
                 }[];
             };
             type: `@rrc/${N}/clearQueryState`;
         };
         clearMutationState: {
-            <K_4 extends keyof MP & keyof MR>(mutationKeys: K_4[]): {
+            <K extends keyof MP & keyof MR>(mutationKeys: K[]): {
                 type: `@rrc/${N}/clearMutationState`;
-                mutationKeys: K_4[];
+                mutationKeys: K[];
             };
             type: `@rrc/${N}/clearMutationState`;
         };
     };
     selectors: {
         /** Selects query state. */
-        selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => QueryState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>;
+        selectQueryState: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => QueryState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>;
         /** Selects query latest result. */
-        selectQueryResult: <QK_2 extends keyof QP | keyof QR>(state: unknown, query: QK_2, cacheKey: Key) => (QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never) | undefined;
+        selectQueryResult: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => (QK extends keyof QP & keyof QR ? QR[QK] : never) | undefined;
         /** Selects query loading state. */
-        selectQueryLoading: <QK_3 extends keyof QP | keyof QR>(state: unknown, query: QK_3, cacheKey: Key) => boolean;
+        selectQueryLoading: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => boolean;
         /** Selects query latest error. */
-        selectQueryError: <QK_4 extends keyof QP | keyof QR>(state: unknown, query: QK_4, cacheKey: Key) => Error | undefined;
+        selectQueryError: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => Error | undefined;
         /** Selects query latest params. */
-        selectQueryParams: <QK_5 extends keyof QP | keyof QR>(state: unknown, query: QK_5, cacheKey: Key) => (QK_5 extends keyof QP & keyof QR ? QP[QK_5] : never) | undefined;
+        selectQueryParams: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => (QK extends keyof QP & keyof QR ? QP[QK] : never) | undefined;
         /** Selects query latest expiresAt. */
-        selectQueryExpiresAt: <QK_6 extends keyof QP | keyof QR>(state: unknown, query: QK_6, cacheKey: Key) => number | undefined;
+        selectQueryExpiresAt: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => number | undefined;
         /** Selects mutation state. */
-        selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => MutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never, MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>;
+        selectMutationState: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => MutationState<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MR[MK] : never>;
         /** Selects mutation latest result. */
-        selectMutationResult: <MK_2 extends keyof MP | keyof MR>(state: unknown, mutation: MK_2) => (MK_2 extends keyof MP & keyof MR ? MR[MK_2] : never) | undefined;
+        selectMutationResult: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => (MK extends keyof MP & keyof MR ? MR[MK] : never) | undefined;
         /** Selects mutation loading state. */
-        selectMutationLoading: <MK_3 extends keyof MP | keyof MR>(state: unknown, mutation: MK_3) => boolean;
+        selectMutationLoading: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => boolean;
         /** Selects mutation latest error. */
-        selectMutationError: <MK_4 extends keyof MP | keyof MR>(state: unknown, mutation: MK_4) => Error | undefined;
+        selectMutationError: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => Error | undefined;
         /** Selects mutation latest params. */
-        selectMutationParams: <MK_5 extends keyof MP | keyof MR>(state: unknown, mutation: MK_5) => (MK_5 extends keyof MP & keyof MR ? MP[MK_5] : never) | undefined;
+        selectMutationParams: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => (MK extends keyof MP & keyof MR ? MP[MK] : never) | undefined;
         /** Selects entity by id and typename. */
         selectEntityById: <TN extends string>(state: unknown, id: Key | null | undefined, typename: TN) => object | undefined;
         /** Selects all entities. */
         selectEntities: (state: unknown) => import("./types").EntitiesMap<Typenames>;
         /** Selects all entities of provided typename. */
-        selectEntitiesByTypename: <TN_1 extends string>(state: unknown, typename: TN_1) => import("./types").Dict<object> | undefined;
+        selectEntitiesByTypename: <TN extends string>(state: unknown, typename: TN) => import("./types").Dict<object> | undefined;
     };
     hooks: {
         /** Returns client object with query and mutate functions. */
         useClient: () => {
-            query: <QK_7 extends keyof QP | keyof QR>(options: QueryOptions<Typenames, QP, QR, QK_7>) => Promise<QueryResult<QK_7 extends keyof QP & keyof QR ? QR[QK_7] : never>>;
-            mutate: <MK_6 extends keyof MP | keyof MR>(options: MutateOptions<Typenames, MP, MR, MK_6>) => Promise<MutationResult<MK_6 extends keyof MP & keyof MR ? MR[MK_6] : never>>;
+            query: <QK extends keyof QP | keyof QR>(options: QueryOptions<Typenames, QP, QR, QK>) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;
+            mutate: <MK extends keyof MP | keyof MR>(options: MutateOptions<Typenames, MP, MR, MK>) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;
         };
         /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
-        useQuery: <QK_8 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<Typenames, QP, QR, QK_8>) => readonly [Omit<QueryState<QK_8 extends keyof QP & keyof QR ? QP[QK_8] : never, QK_8 extends keyof QP & keyof QR ? QR[QK_8] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<Typenames, QP, QR, QK_8>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK_8 extends infer T_4 ? T_4 extends QK_8 ? T_4 extends keyof QP & keyof QR ? QR[T_4] : never : never : never>>];
+        useQuery: <QK extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<Typenames, QP, QR, QK>) => readonly [Omit<QueryState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<Typenames, QP, QR, QK>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK extends infer T ? T extends QK ? T extends keyof QP & keyof QR ? QR[T] : never : never : never>>];
         /** Subscribes to provided mutation state and provides mutate function. */
-        useMutation: <MK_7 extends keyof MP | keyof MR>(options: Omit<MutateOptions<Typenames, MP, MR, MK_7>, "params">) => readonly [(params: MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never) => Promise<MutationResult<MK_7 extends infer T_5 ? T_5 extends MK_7 ? T_5 extends keyof MP & keyof MR ? MR[T_5] : never : never : never>>, MutationState<MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never, MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never>, () => boolean];
+        useMutation: <MK extends keyof MP | keyof MR>(options: Omit<MutateOptions<Typenames, MP, MR, MK>, "params">) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<MutationResult<MK extends infer T ? T extends MK ? T extends keyof MP & keyof MR ? MR[T] : never : never : never>>, MutationState<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
         /** useSelector + selectEntityById. */
-        useSelectEntityById: <TN_2 extends string>(id: Key | null | undefined, typename: TN_2) => object | undefined;
+        useSelectEntityById: <TN extends string>(id: Key | null | undefined, typename: TN) => object | undefined;
     };
     utils: {
         /**

package/dist/createCache.js

@@ -53,12 +53,12 @@ const withTypenames = () => {
             const selectQueryState = (state, query, cacheKey) => {
                 var _a;
                 // @ts-expect-error fix later
-                return (_a = cache.cacheStateSelector(state).queries[query][cacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+                return (_a = cache.cacheStateSelector(state).queries[query][cacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
             };
             const selectMutationState = (state, mutation) => {
                 var _a;
                 // @ts-expect-error fix later
-                return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+                return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
             };
             const actions = (0, createActions_1.createActions)(cache.name);
             return {
@@ -76,7 +76,8 @@ const withTypenames = () => {
                     },
                     /** Selects query loading state. */
                     selectQueryLoading: (state, query, cacheKey) => {
-                        return selectQueryState(state, query, cacheKey).loading;
+                        var _a;
+                        return (_a = selectQueryState(state, query, cacheKey).loading) !== null && _a !== void 0 ? _a : false;
                     },
                     /** Selects query latest error. */
                     selectQueryError: (state, query, cacheKey) => {
@@ -98,7 +99,8 @@ const withTypenames = () => {
                     },
                     /** Selects mutation loading state. */
                     selectMutationLoading: (state, mutation) => {
-                        return selectMutationState(state, mutation).loading;
+                        var _a;
+                        return (_a = selectMutationState(state, mutation).loading) !== null && _a !== void 0 ? _a : false;
                     },
                     /** Selects mutation latest error. */
                     selectMutationError: (state, mutation) => {

package/dist/createCacheReducer.d.ts

@@ -1,42 +1,12 @@
 import type { ActionMap } from './createActions';
 import type { CacheOptions, Dict, EntitiesMap, MutationState, QueryState, Typenames } from './types';
 export type ReduxCacheState<T extends Typenames, QP, QR, MP, MR> = ReturnType<ReturnType<typeof createCacheReducer<string, T, QP, QR, MP, MR>>>;
-export declare const createCacheReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(actions: ActionMap<N, T, QP, QR, MP, MR>, queryKeys: (keyof QP & keyof QR)[], cacheOptions: CacheOptions) => (state: {
+export declare const createCacheReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(actions: ActionMap<N, T, QP, QR, MP, MR>, queryKeys: (keyof (QP | QR))[], cacheOptions: CacheOptions) => (state: {
     entities: EntitiesMap<T>;
-    queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
-    mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: MutationState<MP[MK], MR[MK]>; } : never;
-} | undefined, action: {
-    type: `@rrc/${N}/updateQueryStateAndEntities`;
-    queryKey: keyof QP & keyof QR;
-    queryCacheKey: import("./types").Key;
-    state: Partial<QueryState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
-    entityChanges: import("./types").EntityChanges<T> | undefined;
-} | {
-    type: `@rrc/${N}/updateMutationStateAndEntities`;
-    mutationKey: keyof MP & keyof MR;
-    state: Partial<MutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
-    entityChanges: import("./types").EntityChanges<T> | undefined;
-} | {
-    type: `@rrc/${N}/mergeEntityChanges`;
-    changes: import("./types").EntityChanges<T>;
-} | {
-    type: `@rrc/${N}/invalidateQuery`;
-    queries: {
-        query: keyof QP & keyof QR;
-        cacheKey?: import("./types").Key | undefined;
-        expiresAt?: number | undefined;
-    }[];
-} | {
-    type: `@rrc/${N}/clearQueryState`;
-    queries: {
-        query: keyof QP & keyof QR;
-        cacheKey?: import("./types").Key | undefined;
-    }[];
-} | {
-    type: `@rrc/${N}/clearMutationState`;
-    mutationKeys: (keyof MP & keyof MR)[];
-}) => {
+    queries: { [QK in keyof (QP | QR)]: Dict<QueryState<QP[QK], QR[QK]> | undefined>; };
+    mutations: { [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>; };
+} | undefined, action: ReturnType<(typeof actions)[keyof typeof actions]>) => {
     entities: EntitiesMap<T>;
-    queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
-    mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: MutationState<MP[MK], MR[MK]>; } : never;
+    queries: { [QK in keyof (QP | QR)]: Dict<QueryState<QP[QK], QR[QK]> | undefined>; };
+    mutations: { [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>; };
 };

package/dist/createCacheReducer.js

@@ -1,4 +1,15 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCacheReducer = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
@@ -23,22 +34,25 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
         });
     const deepEqual = cacheOptions.deepComparisonEnabled ? utilsAndConstants_1.optionalUtils.deepEqual : undefined;
     return (state = initialState, action) => {
-        var _a, _b;
         switch (action.type) {
             case actions.updateQueryStateAndEntities.type: {
                 const { queryKey, queryCacheKey, state: queryState, entityChanges, } = action;
-                const oldQueryState = (_a = state.queries[queryKey][queryCacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+                const oldQueryState = state.queries[queryKey][queryCacheKey];
                 let newQueryState = queryState && Object.assign(Object.assign({}, oldQueryState), queryState);
-                // remove undefined optional fields
                 if (newQueryState) {
+                    // remove undefined optional fields
                     for (const key of optionalQueryKeys) {
                         if (key in newQueryState && newQueryState[key] === undefined) {
                             delete newQueryState[key];
                         }
                     }
-                }
-                if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldQueryState, newQueryState)) {
-                    newQueryState = undefined;
+                    if ('loading' in newQueryState && !newQueryState.loading) {
+                        delete newQueryState.loading;
+                    }
+                    // skip if new state deep equals to the old state
+                    if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldQueryState !== null && oldQueryState !== void 0 ? oldQueryState : utilsAndConstants_1.EMPTY_OBJECT, newQueryState)) {
+                        newQueryState = undefined;
+                    }
                 }
                 const newEntities = entityChanges && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChanges, cacheOptions);
                 let newState;
@@ -47,25 +61,37 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
                     newState.entities = newEntities;
                 }
                 if (newQueryState) {
-                    newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
-                    newState.queries = Object.assign(Object.assign({}, state.queries), { [queryKey]: Object.assign(Object.assign({}, state.queries[queryKey]), { [queryCacheKey]: newQueryState }) });
+                    if (!(0, utilsAndConstants_1.isEmptyObject)(newQueryState)) {
+                        newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
+                        newState.queries = Object.assign(Object.assign({}, state.queries), { [queryKey]: Object.assign(Object.assign({}, state.queries[queryKey]), { [queryCacheKey]: newQueryState }) });
+                    }
+                    else if (oldQueryState !== undefined) {
+                        // empty states are removed
+                        const _a = state.queries[queryKey], _b = queryCacheKey, _ = _a[_b], withoutCacheKey = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+                        newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
+                        newState.queries = Object.assign(Object.assign({}, state.queries), { [queryKey]: withoutCacheKey });
+                    }
                 }
                 return newState !== null && newState !== void 0 ? newState : state;
             }
             case actions.updateMutationStateAndEntities.type: {
                 const { mutationKey, state: mutationState, entityChanges, } = action;
-                const oldMutationState = (_b = state.mutations[mutationKey]) !== null && _b !== void 0 ? _b : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+                const oldMutationState = state.mutations[mutationKey];
                 let newMutationState = mutationState && Object.assign(Object.assign({}, oldMutationState), mutationState);
-                // remove undefined optional fields
                 if (newMutationState) {
+                    // remove optional fields with default values
                     for (const key of optionalMutationKeys) {
                         if (key in newMutationState && newMutationState[key] === undefined) {
                             delete newMutationState[key];
                         }
                     }
-                }
-                if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldMutationState, newMutationState)) {
-                    newMutationState = undefined;
+                    if ('loading' in newMutationState && !newMutationState.loading) {
+                        delete newMutationState.loading;
+                    }
+                    // skip if new state deep equals to the old state
+                    if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldMutationState !== null && oldMutationState !== void 0 ? oldMutationState : utilsAndConstants_1.EMPTY_OBJECT, newMutationState)) {
+                        newMutationState = undefined;
+                    }
                 }
                 const newEntities = entityChanges && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChanges, cacheOptions);
                 let newState;
@@ -74,8 +100,16 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
                     newState.entities = newEntities;
                 }
                 if (newMutationState) {
-                    newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
-                    newState.mutations = Object.assign(Object.assign({}, state.mutations), { [mutationKey]: newMutationState });
+                    if (!(0, utilsAndConstants_1.isEmptyObject)(newMutationState)) {
+                        newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
+                        newState.mutations = Object.assign(Object.assign({}, state.mutations), { [mutationKey]: newMutationState });
+                    }
+                    else if (oldMutationState !== undefined) {
+                        // empty states are removed
+                        const _c = state.mutations, _d = mutationKey, _ = _c[_d], withoutMutationKey = __rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
+                        newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
+                        newState.mutations = withoutMutationKey;
+                    }
                 }
                 return newState !== null && newState !== void 0 ? newState : state;
             }
@@ -86,7 +120,7 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
             }
             case actions.invalidateQuery.type: {
                 const { queries: queriesToInvalidate } = action;
-                if (!queriesToInvalidate.length) {
+                if (queriesToInvalidate.length === 0) {
                     return state;
                 }
                 const now = Date.now();
@@ -125,13 +159,13 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
                         }
                     }
                 }
-                return !newQueries
+                return newQueries === undefined
                     ? state
                     : Object.assign(Object.assign({}, state), { queries: newQueries });
             }
             case actions.clearQueryState.type: {
                 const { queries: queriesToClear } = action;
-                if (!queriesToClear.length) {
+                if (queriesToClear.length === 0) {
                     return state;
                 }
                 let newQueries = undefined;
@@ -151,13 +185,13 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
                         newQueries[queryKey] = utilsAndConstants_1.EMPTY_OBJECT;
                     }
                 }
-                return !newQueries
+                return newQueries === undefined
                     ? state
                     : Object.assign(Object.assign({}, state), { queries: newQueries });
             }
             case actions.clearMutationState.type: {
                 const { mutationKeys } = action;
-                if (!mutationKeys.length) {
+                if (mutationKeys.length === 0) {
                     return state;
                 }
                 let newMutations = undefined;
@@ -167,7 +201,7 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
                         delete newMutations[mutation];
                     }
                 }
-                return !newMutations
+                return newMutations === undefined
                     ? state
                     : Object.assign(Object.assign({}, state), { mutations: newMutations });
             }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { createCache, withTypenames } from './createCache';
 export type { ReduxCacheState } from './createCacheReducer';
 export * from './types';
-export { defaultGetCacheKey, DEFAULT_QUERY_MUTATION_STATE as defaultQueryMutationState, } from './utilsAndConstants';
+export { defaultGetCacheKey } from './utilsAndConstants';

package/dist/index.js

@@ -14,21 +14,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultQueryMutationState = exports.defaultGetCacheKey = exports.withTypenames = exports.createCache = void 0;
+exports.defaultGetCacheKey = exports.withTypenames = exports.createCache = void 0;
 var createCache_1 = require("./createCache");
 Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return createCache_1.createCache; } });
 Object.defineProperty(exports, "withTypenames", { enumerable: true, get: function () { return createCache_1.withTypenames; } });
 __exportStar(require("./types"), exports);
 var utilsAndConstants_1 = require("./utilsAndConstants");
 Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetCacheKey; } });
-Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true, get: function () { return utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE; } });
 // Backlog
 // ! high (1.0.0)
-// remove undefined optional fields & emtpy states. remove mutation state when it finished without errors
 // remove cachePolicy? make skip/enabled a function? skip -> enabled/shouldFetch?
 // generate full api docs
 // ! medium
-// example rca -> vite
 // optimistic response
 // reset [whole] cache to initial / to provided state
 // globals for success, completions and loading states?

package/dist/mutate.d.ts

@@ -1,4 +1,4 @@
 import { Store } from 'redux';
 import type { ActionMap } from './createActions';
 import type { Cache, Key, MutationResult, Typenames } from './types';
-export declare const mutate: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof MP | keyof MR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateMutationStateAndEntities, }: Pick<ActionMap<N, T, unknown, unknown, MP, MR>, "updateMutationStateAndEntities">, mutationKey: MK, params: MK extends keyof MP & keyof MR ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>, onCompleted?: ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & string]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & number]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & symbol]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onSuccess?: ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & string]>, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & number]>, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & symbol]>, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onError?: ((error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | undefined) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;
+export declare const mutate: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateMutationStateAndEntities, }: Pick<ActionMap<N, T, unknown, unknown, MP, MR>, "updateMutationStateAndEntities">, mutationKey: MK, params: MK extends keyof (MP | MR) ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & string] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & number] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]>, params: MP[keyof MP & keyof MR & string] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]>, params: MP[keyof MP & keyof MR & number] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]>, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store) => void) | undefined, onError?: ((error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store) => boolean | void | null | undefined) | undefined) => Promise<MutationResult<MK extends keyof (MP | MR) ? MR[MK] : never>>;

package/dist/mutate.js

@@ -11,8 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mutate = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const mutate = (logTag, store, cache, { updateMutationStateAndEntities, }, mutationKey, params, abortControllers, onCompleted = cache.mutations[mutationKey].onCompleted, onSuccess = cache.mutations[mutationKey].onSuccess, onError = cache.mutations[mutationKey].onError) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
+const mutate = (logTag_1, store_1, cache_1, _a, mutationKey_1, params_1, abortControllers_1, ...args_1) => __awaiter(void 0, [logTag_1, store_1, cache_1, _a, mutationKey_1, params_1, abortControllers_1, ...args_1], void 0, function* (logTag, store, cache, { updateMutationStateAndEntities, }, mutationKey, params, abortControllers, onCompleted = cache.mutations[mutationKey].onCompleted, onSuccess = cache.mutations[mutationKey].onSuccess, onError = cache.mutations[mutationKey].onError) {
+    var _b, _c;
     let abortControllersOfStore = abortControllers.get(store);
     if (abortControllersOfStore === undefined) {
         abortControllersOfStore = {};
@@ -68,7 +68,7 @@ const mutate = (logTag, store, cache, { updateMutationStateAndEntities, }, mutat
         // @ts-expect-error params
         if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store))) {
             // @ts-expect-error queryKey
-            (_b = (_a = cache.globals).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error, mutationKey, params, store);
+            (_c = (_b = cache.globals).onError) === null || _c === void 0 ? void 0 : _c.call(_b, error, mutationKey, params, store);
         }
         // @ts-expect-error response
         onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response, error, params, store);

package/dist/query.d.ts

@@ -1,4 +1,4 @@
 import { Store } from 'redux';
 import type { ActionMap } from './createActions';
 import type { Cache, Key, QueryResult, Typenames } from './types';
-export declare const query: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateQueryStateAndEntities, }: Pick<ActionMap<N, T, QP, QR, unknown, unknown>, "updateQueryStateAndEntities">, queryKey: QK, cacheKey: Key, params: QK extends keyof QP & keyof QR ? QP[QK] : never, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & symbol]) | undefined, onCompleted?: ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onSuccess?: ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onError?: ((error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | undefined) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;
+export declare const query: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof (QP & QR)>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateQueryStateAndEntities, }: Pick<ActionMap<N, T, QP, QR, unknown, unknown>, "updateQueryStateAndEntities">, queryKey: QK, cacheKey: Key, params: QK extends keyof (QP | QR) ? QP[QK] : never, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store) => QR[keyof QP & keyof QR & symbol]) | undefined, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & string] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & number] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store) => void) | undefined, onError?: ((error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store) => boolean | void | null | undefined) | undefined) => Promise<QueryResult<QK extends keyof (QP | QR) ? QR[QK] : never>>;

package/dist/types.d.ts

@@ -76,15 +76,10 @@ export type EntitiesMap<T extends Typenames> = {
 export type EntityIds<T extends Typenames> = {
     [K in keyof T]?: Key[];
 };
-export type Query<P, T extends Typenames = Typenames, R = unknown> = (
-/** Query parameters */
-params: P, 
-/** Redux store */
-store: Store) => Promise<QueryResponse<T, R>>;
-export type QueryInfo<T extends Typenames, P, R> = Partial<Pick<Globals<unknown, unknown>, 'cachePolicy' | 'secondsToLive'>> & {
-    query: Query<P, T, R>;
+export type QueryInfo<T extends Typenames = Typenames, P = unknown, R = unknown> = Partial<Pick<Globals<unknown, unknown>, 'cachePolicy' | 'secondsToLive'>> & {
+    query: NormalizedQuery<T, P, R>;
     /** Merges results before saving to the store. Default implementation is using the latest result. */
-    mergeResults?: (oldResult: R | undefined, response: QueryResponse<T, R>, params: P | undefined, store: Store) => R;
+    mergeResults?: (oldResult: R | undefined, response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store) => 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 `JSON.stringify` or `String()` depending on type.
@@ -92,12 +87,18 @@ export type QueryInfo<T extends Typenames, P, R> = Partial<Pick<Globals<unknown,
      * */
     getCacheKey?: (params?: P) => Key;
     /** Called after fetch finished either successfully or not. */
-    onCompleted?: (response: QueryResponse<T, R> | undefined, error: unknown | undefined, params: P | undefined, store: Store) => void;
+    onCompleted?: (response: NormalizedQueryResponse<T, R> | undefined, error: unknown | undefined, params: P | undefined, store: Store) => void;
     /** Called after fetch finished without error. */
-    onSuccess?: (response: QueryResponse<T, R>, params: P | undefined, store: Store) => void;
+    onSuccess?: (response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store) => 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) => boolean | void | null | undefined;
 };
+export type Query<P = unknown, R = unknown> = (
+/** Query parameters */
+params: P, 
+/** Redux 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<P, R> = MutationState<P, R> & {
     expiresAt?: number;
 };
@@ -112,41 +113,44 @@ export type QueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)
     onlyIfExpired?: boolean;
 };
 export type QueryCachePolicy = 'cache-first' | 'cache-and-fetch';
-export type QueryResponse<T extends Typenames, R> = EntityChanges<T> & {
+export type QueryResponse<R = unknown> = {
     result: R;
     /** If defined, overrides this value for query state, ignoring `secondsToLive`. */
     expiresAt?: number;
 };
-export type QueryResult<R> = {
+export type NormalizedQueryResponse<T extends Typenames = Typenames, R = unknown> = EntityChanges<T> & QueryResponse<R>;
+export type QueryResult<R = unknown> = {
     error?: unknown;
     cancelled?: true;
     result?: R;
 };
-export type Mutation<P, T extends Typenames = Typenames, R = unknown> = (
+export type MutationInfo<T extends Typenames = Typenames, P = unknown, R = unknown> = Pick<QueryInfo<T, P, R>, 'onCompleted' | 'onSuccess' | 'onError'> & {
+    mutation: NormalizedMutation<T, P, R>;
+};
+export type Mutation<P = unknown, R = unknown> = (
 /** Mutation parameters */
 params: P, 
 /** Redux store */
 store: Store, 
 /** Signal is aborted for current mutation when the same mutation was called once again. */
-abortSignal: AbortSignal) => Promise<MutationResponse<T, R>>;
-export type MutationInfo<T extends Typenames, P, R> = Pick<QueryInfo<T, P, R>, 'onCompleted' | 'onSuccess' | 'onError'> & {
-    mutation: Mutation<P, T, R>;
-};
+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<T extends Typenames, MP, MR, MK extends keyof (MP & MR)> = Pick<MutationInfo<T, MK extends keyof (MP | MR) ? MP[MK] : never, MK extends keyof (MP | MR) ? MR[MK] : never>, 'onCompleted' | 'onSuccess' | 'onError'> & {
     mutation: MK;
     params: MK extends keyof (MP | MR) ? MP[MK] : never;
 };
-export type MutationResponse<T extends Typenames, R> = EntityChanges<T> & {
+export type MutationResponse<R = unknown> = {
     result?: R;
 };
-export type MutationResult<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;
 };
 export type MutationState<P, R> = {
-    /** `true` when query or mutation is currently in progress. */
-    loading: boolean;
+    /** `true` when fetch is currently in progress. */
+    loading?: boolean;
     /** Result of the latest successfull response. */
     result?: R;
     /** Error of the latest response. */

package/dist/useMutation.d.ts

@@ -1,4 +1,4 @@
 import { Store } from 'redux';
 import { ActionMap } from './createActions';
 import { Cache, Key, MutateOptions, MutationState, Typenames } from './types';
-export declare const useMutation: <N extends string, T extends Typenames, MP, MR, MK extends keyof MP | keyof MR>(cache: Cache<N, T, unknown, unknown, MP, MR>, actions: Pick<ActionMap<N, T, unknown, unknown, MP, MR>, "updateMutationStateAndEntities">, options: Omit<MutateOptions<T, 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<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
+export declare const useMutation: <N extends string, T extends Typenames, MP, MR, MK extends keyof (MP & MR)>(cache: Cache<N, T, unknown, unknown, MP, MR>, actions: Pick<ActionMap<N, T, unknown, unknown, MP, MR>, "updateMutationStateAndEntities">, options: Omit<MutateOptions<T, 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<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];

package/dist/useMutation.js

@@ -53,7 +53,7 @@ const useMutation = (cache, actions, options, abortControllers) => {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [mutationKey, store]);
     // @ts-expect-error fix later
-    const mutationState = (_a = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+    const mutationState = (_a = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
     cache.options.logsEnabled &&
         (0, utilsAndConstants_1.log)('useMutation', {
             options,

package/dist/useQuery.d.ts

@@ -1,3 +1,3 @@
 import { ActionMap } from './createActions';
 import { Cache, QueryOptions, QueryState, Typenames, UseQueryOptions } from './types';
-export declare const useQuery: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Pick<ActionMap<N, T, QP, QR, MP, MR>, "updateQueryStateAndEntities">, options: UseQueryOptions<T, QP, QR, QK>) => readonly [Omit<QueryState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<T, QP, QR, QK>, "params" | "onlyIfExpired">> | undefined) => Promise<import("./types").QueryResult<QK extends infer T_1 ? T_1 extends QK ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];
+export declare const useQuery: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof (QP & QR)>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Pick<ActionMap<N, T, QP, QR, MP, MR>, "updateQueryStateAndEntities">, options: UseQueryOptions<T, QP, QR, QK>) => readonly [Omit<QueryState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<T, QP, QR, QK>, "params" | "onlyIfExpired">>) => Promise<import("./types").QueryResult<QK extends infer T_1 ? T_1 extends QK ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];

package/dist/useQuery.js

@@ -39,7 +39,7 @@ const useQuery = (cache, actions, options) => {
     const queryState = (_c = (0, react_redux_1.useSelector)((state) => {
         const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
-    }, (useQueryStateComparer))) !== null && _c !== void 0 ? _c : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+    }, (useQueryStateComparer))) !== null && _c !== void 0 ? _c : utilsAndConstants_1.EMPTY_OBJECT;
     (0, react_1.useEffect)(() => {
         if (skip) {
             logsEnabled && (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch', { skip, cacheKey });

package/dist/utilsAndConstants.d.ts

@@ -4,11 +4,9 @@ export declare const optionalUtils: {
     deepEqual?: (a: any, b: any) => boolean;
 };
 export declare const IS_DEV: boolean;
-export declare const DEFAULT_QUERY_MUTATION_STATE: Readonly<{
-    loading: false;
-}>;
 export declare const EMPTY_OBJECT: Readonly<{}>;
 export declare const EMPTY_ARRAY: readonly never[];
 export declare const defaultGetCacheKey: <P = unknown>(params: P) => Key;
 export declare const log: (tag: string, data?: unknown) => void;
 export declare const applyEntityChanges: <T extends Typenames>(entities: EntitiesMap<T>, changes: EntityChanges<T>, options: CacheOptions) => EntitiesMap<T> | undefined;
+export declare const isEmptyObject: (o: object) => boolean;

package/dist/utilsAndConstants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.EMPTY_ARRAY = exports.EMPTY_OBJECT = exports.DEFAULT_QUERY_MUTATION_STATE = exports.IS_DEV = exports.optionalUtils = exports.PACKAGE_SHORT_NAME = void 0;
+exports.isEmptyObject = exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.EMPTY_ARRAY = exports.EMPTY_OBJECT = exports.IS_DEV = exports.optionalUtils = exports.PACKAGE_SHORT_NAME = void 0;
 exports.PACKAGE_SHORT_NAME = 'rrc';
 exports.optionalUtils = {
     deepEqual: undefined,
@@ -20,7 +20,6 @@ exports.IS_DEV = (() => {
         return process.env.NODE_ENV === 'development';
     }
 })();
-exports.DEFAULT_QUERY_MUTATION_STATE = Object.freeze({ loading: false });
 exports.EMPTY_OBJECT = Object.freeze({});
 exports.EMPTY_ARRAY = Object.freeze([]);
 const defaultGetCacheKey = (params) => {
@@ -124,3 +123,10 @@ const applyEntityChanges = (entities, changes, options) => {
     return result;
 };
 exports.applyEntityChanges = applyEntityChanges;
+const isEmptyObject = (o) => {
+    for (const _ in o) {
+        return false;
+    }
+    return true;
+};
+exports.isEmptyObject = isEmptyObject;

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.10.0",
+  "version": "0.12.0-rc.0",
   "description": "Powerful data fetching and caching library that supports normalization, built on top of redux",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -51,7 +51,7 @@
     "redux": "4.2.1",
     "redux-logger": "3.0.6",
     "ts-jest": "29.1.0",
-    "typescript": "5.0"
+    "typescript": "5.6.3"
   },
   "files": [
     "dist/*"