react-redux-cache 0.19.4 → 0.19.6

package/README.md

@@ -23,7 +23,7 @@ Can be considered as `ApolloClient` for protocols other than `GraphQL`, but with
 |Not overengineered|Simplicity is the main goal.|
 |Performance|Every function is heavily optimized, Immer is not used ([RTK [Query] issue](https://github.com/reduxjs/redux-toolkit/issues/4793)).|
 |Reliability|High test coverage, zero issue policy.|
-|Lightweight|`npx minified-size dist/esm/*.js`<br/>minified: 18.3 kB<br/>gzipped: 7.91 kB<br/>brotlied: 7.02 kB|
+|Lightweight|`npx minified-size dist/esm/*.js`<br/>minified: 18.2 kB<br/>gzipped: 7.91 kB<br/>brotlied: 7.03 kB|
 
 |Feature|Description|
 |--|--|
@@ -127,6 +127,8 @@ Can be considered as `ApolloClient` for protocols other than `GraphQL`, but with
   }
   ```
 </details>
+
+[API Reference](DOCUMENTATION.md)
     
 ### Table of contents
 

package/dist/cjs/createCache.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, '__esModule', {value: true})
 exports.createCache = exports.withTypenames = void 0
 const react_1 = require('react')
 const createActions_1 = require('./createActions')
-const createCacheReducer_1 = require('./createCacheReducer')
+const createReducer_1 = require('./createReducer')
 const createSelectors_1 = require('./createSelectors')
 const mutate_1 = require('./mutate')
 const query_1 = require('./query')
@@ -100,11 +100,7 @@ const withTypenames = () => {
         clearMutationState,
         clearCache,
       } = actions
-      const reducer = (0, createCacheReducer_1.createCacheReducer)(
-        actions,
-        Object.keys(cache.queries),
-        cache.options
-      )
+      const reducer = (0, createReducer_1.createReducer)(actions, Object.keys(cache.queries), cache.options)
       const createClient = (store) => {
         const client = {
           query: (options) => {
@@ -126,6 +122,7 @@ const withTypenames = () => {
               params,
               options.secondsToLive,
               options.onlyIfExpired,
+              options.skipFetch,
               options.mergeResults,
               options.onCompleted,
               options.onSuccess,

package/dist/cjs/{createCacheReducer.js → createReducer.js}

@@ -18,12 +18,12 @@ var __rest =
     return t
   }
 Object.defineProperty(exports, '__esModule', {value: true})
-exports.createCacheReducer = void 0
+exports.createReducer = void 0
 const utilsAndConstants_1 = require('./utilsAndConstants')
 
 const optionalQueryKeys = ['error', 'expiresAt', 'result', 'params', 'loading']
 const optionalMutationKeys = ['error', 'result', 'params', 'loading']
-const createCacheReducer = (actions, queryKeys, cacheOptions) => {
+const createReducer = (actions, queryKeys, cacheOptions) => {
   const initialState = Object.freeze({
     entities: Object.freeze({}),
     queries: Object.freeze(
@@ -282,4 +282,4 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
     return state
   }
 }
-exports.createCacheReducer = createCacheReducer
+exports.createReducer = createReducer

package/dist/cjs/query.js

@@ -45,6 +45,7 @@ const query = (
   params,
   secondsToLive,
   onlyIfExpired,
+  skipFetch,
   mergeResults,
   onCompleted,
   onSuccess,
@@ -73,6 +74,11 @@ const query = (
     const {selectQueryResult, selectQueryState} = selectors
     const logsEnabled = cache.options.logsEnabled
     const queryStateOnStart = selectQueryState(store.getState(), queryKey, cacheKey)
+    if (skipFetch) {
+      return {
+        result: queryStateOnStart.result,
+      }
+    }
     if (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.loading) {
       logsEnabled &&
         (0, utilsAndConstants_1.log)(`${logTag} fetch cancelled: already loading`, {

package/dist/cjs/useMutation.js

@@ -38,18 +38,13 @@ const utilsAndConstants_1 = require('./utilsAndConstants')
 
 const useMutation = (cache, actions, selectors, options, abortControllers) => {
   var _a
+  const {selectMutationState} = selectors
+  const {updateMutationStateAndEntities} = actions
   const {mutation: mutationKey, onCompleted, onSuccess, onError} = options
   const store = cache.storeHooks.useStore()
   const [mutationStateSelector, mutate, abort] = (0, react_1.useMemo)(() => {
     return [
-      (state) => {
-        cache.options.logsEnabled &&
-          (0, utilsAndConstants_1.log)('mutationStateSelector', {
-            state,
-            cacheState: cache.cacheStateSelector(state),
-          })
-        return cache.cacheStateSelector(state).mutations[mutationKey]
-      },
+      (state) => selectMutationState(state, mutationKey),
       (params) =>
         __awaiter(void 0, void 0, void 0, function* () {
           return yield (0,
@@ -63,7 +58,7 @@ const useMutation = (cache, actions, selectors, options, abortControllers) => {
           return false
         }
         abortController.abort()
-        store.dispatch(actions.updateMutationStateAndEntities(mutationKey, {loading: undefined}))
+        store.dispatch(updateMutationStateAndEntities(mutationKey, {loading: undefined}))
         return true
       },
     ]

package/dist/cjs/useQuery.js

@@ -75,7 +75,7 @@ const useQuery = (cache, actions, selectors, options) => {
       __awaiter(void 0, void 0, void 0, function* () {
         const paramsPassed = options && 'params' in options
         return yield (0,
-        query_1.query)('useQuery.fetch', store, cache, actions, selectors, queryKey, paramsPassed ? getCacheKey(options.params) : cacheKey, paramsPassed ? options.params : params, secondsToLive, options === null || options === void 0 ? void 0 : options.onlyIfExpired, mergeResults, onCompleted, onSuccess, onError)
+        query_1.query)('useQuery.fetch', store, cache, actions, selectors, queryKey, paramsPassed ? getCacheKey(options.params) : cacheKey, paramsPassed ? options.params : params, secondsToLive, options === null || options === void 0 ? void 0 : options.onlyIfExpired, false, mergeResults, onCompleted, onSuccess, onError)
       }),
     [store, queryKey, cacheKey]
   )

package/dist/cjs/utilsAndConstants.js

@@ -1,9 +1,9 @@
 'use strict'
 Object.defineProperty(exports, '__esModule', {value: true})
-exports.createStateComparer =
+exports.FetchPolicy =
+  exports.createStateComparer =
   exports.isEmptyObject =
   exports.applyEntityChanges =
-  exports.FetchPolicy =
   exports.log =
   exports.defaultGetCacheKey =
   exports.NOOP =
@@ -49,12 +49,6 @@ const log = (tag, data) => {
   console.debug(`@${exports.PACKAGE_SHORT_NAME} [${tag}]`, data)
 }
 exports.log = log
-exports.FetchPolicy = {
-  NoCacheOrExpired: (expired, _params, state) => {
-    return expired || state.result === undefined
-  },
-  Always: () => true,
-}
 const applyEntityChanges = (entities, changes, options) => {
   var _a, _b, _c, _d
   if (changes.merge && changes.entities) {
@@ -187,3 +181,9 @@ const createStateComparer = (fields) => {
   }
 }
 exports.createStateComparer = createStateComparer
+exports.FetchPolicy = {
+  NoCacheOrExpired: (expired, _params, state) => {
+    return expired || state.result === undefined
+  },
+  Always: () => true,
+}

package/dist/esm/createCache.js

@@ -1,7 +1,7 @@
 import {useMemo} from 'react'
 
 import {createActions} from './createActions'
-import {createCacheReducer} from './createCacheReducer'
+import {createReducer} from './createReducer'
 import {createSelectors} from './createSelectors'
 import {mutate as mutateImpl} from './mutate'
 import {query as queryImpl} from './query'
@@ -103,7 +103,7 @@ export const withTypenames = () => {
         clearMutationState,
         clearCache,
       } = actions
-      const reducer = createCacheReducer(actions, Object.keys(cache.queries), cache.options)
+      const reducer = createReducer(actions, Object.keys(cache.queries), cache.options)
       const createClient = (store) => {
         const client = {
           query: (options) => {
@@ -123,6 +123,7 @@ export const withTypenames = () => {
               params,
               options.secondsToLive,
               options.onlyIfExpired,
+              options.skipFetch,
               options.mergeResults,
               options.onCompleted,
               options.onSuccess,
@@ -200,4 +201,5 @@ export const withTypenames = () => {
     },
   }
 }
+
 export const createCache = withTypenames().createCache

package/dist/esm/{createCacheReducer.js → createReducer.js}

@@ -20,7 +20,8 @@ import {applyEntityChanges, EMPTY_OBJECT, isEmptyObject, log, optionalUtils} fro
 
 const optionalQueryKeys = ['error', 'expiresAt', 'result', 'params', 'loading']
 const optionalMutationKeys = ['error', 'result', 'params', 'loading']
-export const createCacheReducer = (actions, queryKeys, cacheOptions) => {
+
+export const createReducer = (actions, queryKeys, cacheOptions) => {
   const initialState = Object.freeze({
     entities: Object.freeze({}),
     queries: Object.freeze(

package/dist/esm/index.js

@@ -1,3 +1,5 @@
 export {createCache, withTypenames} from './createCache'
+
 export * from './types'
+
 export {createStateComparer, defaultGetCacheKey, FetchPolicy, isEmptyObject} from './utilsAndConstants'

package/dist/esm/mutate.js

@@ -154,4 +154,5 @@ export const mutate = (
       throw new Error(`${logTag}: both error and response are not defined`)
     }
   )
+
 const ABORTED_RESULT = Object.freeze({aborted: true})

package/dist/esm/query.js

@@ -42,6 +42,7 @@ export const query = (
   params,
   secondsToLive,
   onlyIfExpired,
+  skipFetch,
   mergeResults,
   onCompleted,
   onSuccess,
@@ -70,6 +71,11 @@ export const query = (
     const {selectQueryResult, selectQueryState} = selectors
     const logsEnabled = cache.options.logsEnabled
     const queryStateOnStart = selectQueryState(store.getState(), queryKey, cacheKey)
+    if (skipFetch) {
+      return {
+        result: queryStateOnStart.result,
+      }
+    }
     if (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.loading) {
       logsEnabled &&
         log(`${logTag} fetch cancelled: already loading`, {
@@ -166,4 +172,5 @@ export const query = (
       result: newState === null || newState === void 0 ? void 0 : newState.result,
     }
   })
+
 const catchAndReturn = (x) => x

package/dist/esm/useMutation.js

@@ -36,18 +36,13 @@ import {EMPTY_OBJECT, log} from './utilsAndConstants'
 
 export const useMutation = (cache, actions, selectors, options, abortControllers) => {
   var _a
+  const {selectMutationState} = selectors
+  const {updateMutationStateAndEntities} = actions
   const {mutation: mutationKey, onCompleted, onSuccess, onError} = options
   const store = cache.storeHooks.useStore()
   const [mutationStateSelector, mutate, abort] = useMemo(() => {
     return [
-      (state) => {
-        cache.options.logsEnabled &&
-          log('mutationStateSelector', {
-            state,
-            cacheState: cache.cacheStateSelector(state),
-          })
-        return cache.cacheStateSelector(state).mutations[mutationKey]
-      },
+      (state) => selectMutationState(state, mutationKey),
       (params) =>
         __awaiter(void 0, void 0, void 0, function* () {
           return yield mutateImpl(
@@ -72,7 +67,7 @@ export const useMutation = (cache, actions, selectors, options, abortControllers
           return false
         }
         abortController.abort()
-        store.dispatch(actions.updateMutationStateAndEntities(mutationKey, {loading: undefined}))
+        store.dispatch(updateMutationStateAndEntities(mutationKey, {loading: undefined}))
         return true
       },
     ]

package/dist/esm/useQuery.js

@@ -82,6 +82,7 @@ export const useQuery = (cache, actions, selectors, options) => {
           paramsPassed ? options.params : params,
           secondsToLive,
           options === null || options === void 0 ? void 0 : options.onlyIfExpired,
+          false,
           mergeResults,
           onCompleted,
           onSuccess,
@@ -122,4 +123,5 @@ export const useQuery = (cache, actions, selectors, options) => {
     })
   return [queryState, performFetch]
 }
+
 const defaultStateComparer = createStateComparer(['result', 'loading', 'params', 'error'])

package/dist/esm/utilsAndConstants.js

@@ -1,12 +1,15 @@
 export const PACKAGE_SHORT_NAME = 'rrc'
+
 export const optionalUtils = {
   deepEqual: undefined,
 }
+
 try {
   optionalUtils.deepEqual = require('fast-deep-equal/es6')
 } catch (_a) {
   console.debug(PACKAGE_SHORT_NAME + ': fast-deep-equal optional dependency was not installed')
 }
+
 export const IS_DEV = (() => {
   try {
     return __DEV__
@@ -14,9 +17,13 @@ export const IS_DEV = (() => {
     return process.env.NODE_ENV === 'development'
   }
 })()
+
 export const EMPTY_OBJECT = Object.freeze({})
+
 export const EMPTY_ARRAY = Object.freeze([])
+
 export const NOOP = () => {}
+
 export const defaultGetCacheKey = (params) => {
   switch (typeof params) {
     case 'string':
@@ -28,15 +35,11 @@ export const defaultGetCacheKey = (params) => {
       return String(params)
   }
 }
+
 export const log = (tag, data) => {
   console.debug(`@${PACKAGE_SHORT_NAME} [${tag}]`, data)
 }
-export const FetchPolicy = {
-  NoCacheOrExpired: (expired, _params, state) => {
-    return expired || state.result === undefined
-  },
-  Always: () => true,
-}
+
 export const applyEntityChanges = (entities, changes, options) => {
   var _a, _b, _c, _d
   if (changes.merge && changes.entities) {
@@ -143,12 +146,14 @@ export const applyEntityChanges = (entities, changes, options) => {
     })
   return result
 }
+
 export const isEmptyObject = (o) => {
   for (const _ in o) {
     return false
   }
   return true
 }
+
 export const createStateComparer = (fields) => {
   return (x, y) => {
     if (x === y) {
@@ -166,3 +171,10 @@ export const createStateComparer = (fields) => {
     return true
   }
 }
+
+export const FetchPolicy = {
+  NoCacheOrExpired: (expired, _params, state) => {
+    return expired || state.result === undefined
+  },
+  Always: () => true,
+}

package/dist/types/createActions.d.ts

@@ -9,6 +9,7 @@ export type Actions<
   MP = unknown,
   MR = unknown
 > = ReturnType<typeof createActions<N, T, QP, QR, MP, MR>>
+
 export declare const createActions: <N extends string, T extends Typenames, QP, QR, MP, MR>(
   name: N
 ) => {

package/dist/types/createCache.d.ts

@@ -1,28 +1,38 @@
 import type {
   Cache,
   CacheOptions,
+  CacheState,
+  Dict,
+  EntitiesMap,
+  EntityChanges,
   Globals,
   Key,
   MutateOptions,
+  MutationInfo,
   MutationResult,
+  MutationState,
+  NormalizedQueryResponse,
   OptionalPartial,
+  QueryInfo,
   QueryOptions,
   QueryResult,
+  QueryState,
   Store,
   Typenames,
+  UseQueryOptions,
 } from './types'
 import {useMutation} from './useMutation'
 import {useQuery} from './useQuery'
 import {applyEntityChanges} from './utilsAndConstants'
+
 /**
  * Function to provide generic Typenames if normalization is needed - this is a Typescript limitation.
  * Returns object with createCache function with provided typenames.
  * @example
- * const cache = withTypenames<MyTypenames>().createCache({
- *   ...
- * })
+ * `const cache = withTypenames<MyTypenames>().createCache({...})`
  */
 export declare const withTypenames: <T extends Typenames = Typenames>() => {
+  /** Creates reducer, actions and hooks for managing queries and mutations through redux cache. */
   createCache: <N extends string, QP, QR, MP, MR>(
     partialCache: OptionalPartial<
       Omit<Cache<N, T, QP, QR, MP, MR>, 'globals'>,
@@ -35,28 +45,24 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
     cache: Cache<N, T, QP, QR, MP, MR>
     /** Reducer of the cache, should be added to redux store. */
     reducer: (
-      state: import('./types').CacheState<T, QP, QR, MP, MR> | undefined,
+      state: CacheState<T, QP, QR, MP, MR> | undefined,
       action:
         | {
             type: `@rrc/${N}/updateQueryStateAndEntities`
             queryKey: keyof QP & keyof QR
             queryCacheKey: Key
-            state:
-              | Partial<import('./types').QueryState<T, QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>>
-              | undefined
-            entityChanges: import('./types').EntityChanges<T> | undefined
+            state: Partial<QueryState<T, QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined
+            entityChanges: EntityChanges<T> | undefined
           }
         | {
             type: `@rrc/${N}/updateMutationStateAndEntities`
             mutationKey: keyof MP & keyof MR
-            state:
-              | Partial<import('./types').MutationState<T, MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>>
-              | undefined
-            entityChanges: import('./types').EntityChanges<T> | undefined
+            state: Partial<MutationState<T, MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined
+            entityChanges: EntityChanges<T> | undefined
           }
         | {
             type: `@rrc/${N}/mergeEntityChanges`
-            changes: import('./types').EntityChanges<T>
+            changes: EntityChanges<T>
           }
         | {
             type: `@rrc/${N}/invalidateQuery`
@@ -79,23 +85,23 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
           }
         | {
             type: `@rrc/${N}/clearCache`
-            stateToKeep: Partial<import('./types').CacheState<T, QP, QR, MP, MR>> | undefined
+            stateToKeep: Partial<CacheState<T, QP, QR, MP, MR>> | undefined
           }
-    ) => import('./types').CacheState<T, QP, QR, MP, MR>
+    ) => CacheState<T, QP, QR, MP, MR>
     actions: {
       /** 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<import('./types').QueryState<T, QP[K], QR[K]>> | undefined,
-          entityChanges?: import('./types').EntityChanges<T> | undefined
+          state?: Partial<QueryState<T, QP[K], QR[K]>> | undefined,
+          entityChanges?: EntityChanges<T> | undefined
         ): {
           type: `@rrc/${N}/updateQueryStateAndEntities`
           queryKey: K
           queryCacheKey: Key
-          state: Partial<import('./types').QueryState<T, QP[K], QR[K]>> | undefined
-          entityChanges: import('./types').EntityChanges<T> | undefined
+          state: Partial<QueryState<T, QP[K], QR[K]>> | undefined
+          entityChanges: EntityChanges<T> | undefined
         }
         type: `@rrc/${N}/updateQueryStateAndEntities`
       }
@@ -103,21 +109,21 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       updateMutationStateAndEntities: {
         <K extends keyof MP & keyof MR>(
           mutationKey: K,
-          state?: Partial<import('./types').MutationState<T, MP[K], MR[K]>> | undefined,
-          entityChanges?: import('./types').EntityChanges<T> | undefined
+          state?: Partial<MutationState<T, MP[K], MR[K]>> | undefined,
+          entityChanges?: EntityChanges<T> | undefined
         ): {
           type: `@rrc/${N}/updateMutationStateAndEntities`
           mutationKey: K
-          state: Partial<import('./types').MutationState<T, MP[K], MR[K]>> | undefined
-          entityChanges: import('./types').EntityChanges<T> | undefined
+          state: Partial<MutationState<T, MP[K], MR[K]>> | undefined
+          entityChanges: EntityChanges<T> | undefined
         }
         type: `@rrc/${N}/updateMutationStateAndEntities`
       }
       /** Merges EntityChanges to the state. */
       mergeEntityChanges: {
-        (changes: import('./types').EntityChanges<T>): {
+        (changes: EntityChanges<T>): {
           type: `@rrc/${N}/mergeEntityChanges`
-          changes: import('./types').EntityChanges<T>
+          changes: EntityChanges<T>
         }
         type: `@rrc/${N}/mergeEntityChanges`
       }
@@ -166,22 +172,22 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       }
       /** Replaces cache state with initial, optionally merging with provided state. Doesn't cancel running fetches and shoult be used with caution. */
       clearCache: {
-        (stateToKeep?: Partial<import('./types').CacheState<T, QP, QR, MP, MR>> | undefined): {
+        (stateToKeep?: Partial<CacheState<T, QP, QR, MP, MR>> | undefined): {
           type: `@rrc/${N}/clearCache`
-          stateToKeep: Partial<import('./types').CacheState<T, QP, QR, MP, MR>> | undefined
+          stateToKeep: Partial<CacheState<T, QP, QR, MP, MR>> | undefined
         }
         type: `@rrc/${N}/clearCache`
       }
     }
     selectors: {
       /** This is a cacheStateSelector from createCache options, or default one if was not provided. */
-      selectCacheState: (state: any) => import('./types').CacheState<T, QP, QR, MP, MR>
+      selectCacheState: (state: any) => CacheState<T, QP, QR, MP, MR>
       /** Selects query state. */
       selectQueryState: <QK extends keyof QP | keyof QR>(
         state: unknown,
         query: QK,
         cacheKey: Key
-      ) => import('./types').QueryState<
+      ) => QueryState<
         T,
         QK extends keyof QP & keyof QR ? QP[QK] : never,
         QK extends keyof QP & keyof QR ? QR[QK] : never
@@ -197,11 +203,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         state: unknown,
         query: QK,
         cacheKey: Key
-      ) =>
-        | false
-        | Promise<
-            import('./types').NormalizedQueryResponse<T, QK extends keyof QP & keyof QR ? QR[QK] : never>
-          >
+      ) => false | Promise<NormalizedQueryResponse<T, QK extends keyof QP & keyof QR ? QR[QK] : never>>
       /** Selects query latest error. */
       selectQueryError: <QK extends keyof QP | keyof QR>(
         state: unknown,
@@ -224,7 +226,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       selectMutationState: <MK extends keyof MP | keyof MR>(
         state: unknown,
         mutation: MK
-      ) => import('./types').MutationState<
+      ) => MutationState<
         T,
         MK extends keyof MP & keyof MR ? MP[MK] : never,
         MK extends keyof MP & keyof MR ? MR[MK] : never
@@ -238,11 +240,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       selectMutationLoading: <MK extends keyof MP | keyof MR>(
         state: unknown,
         mutation: MK
-      ) =>
-        | false
-        | Promise<
-            import('./types').NormalizedQueryResponse<T, MK extends keyof MP & keyof MR ? MR[MK] : never>
-          >
+      ) => false | Promise<NormalizedQueryResponse<T, MK extends keyof MP & keyof MR ? MR[MK] : never>>
       /** Selects mutation latest error. */
       selectMutationError: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => Error | undefined
       /** Selects mutation latest params. */
@@ -257,15 +255,12 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         typename: TN
       ) => T[TN] | undefined
       /** Selects all entities. */
-      selectEntities: (state: unknown) => import('./types').EntitiesMap<T>
+      selectEntities: (state: unknown) => EntitiesMap<T>
       /** Selects all entities of provided typename. */
-      selectEntitiesByTypename: <TN extends keyof T>(
-        state: unknown,
-        typename: TN
-      ) => import('./types').EntitiesMap<T>[TN]
+      selectEntitiesByTypename: <TN extends keyof T>(state: unknown, typename: TN) => EntitiesMap<T>[TN]
     }
     hooks: {
-      /** Returns client object with query and mutate functions. */
+      /** Returns memoized object with query and mutate functions. Memoization dependency is the store. */
       useClient: () => {
         query: <QK extends keyof (QP & QR)>(
           options: QueryOptions<N, T, QP, QR, QK, MP, MR>
@@ -274,12 +269,12 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
           options: MutateOptions<N, T, QP, QR, 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). */
+      /** Fetches query when params change and subscribes to query state changes (subscription depends on `selectorComparer`). */
       useQuery: <QK extends keyof (QP & QR)>(
         options: Parameters<typeof useQuery<N, T, QP, QR, MP, MR, QK>>[3]
       ) => readonly [
         Omit<
-          import('./types').QueryState<
+          QueryState<
             T,
             QK extends keyof QP & keyof QR ? QP[QK] : never,
             QK extends keyof QP & keyof QR ? QR[QK] : never
@@ -319,7 +314,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
               : never
           >
         >,
-        import('./types').MutationState<
+        MutationState<
           T,
           MK extends keyof MP & keyof MR ? MP[MK] : never,
           MK extends keyof MP & keyof MR ? MP[MK] : never
@@ -340,16 +335,17 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         ) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>
       }
       /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
-      getInitialState: () => import('./types').CacheState<T, QP, QR, MP, MR>
+      getInitialState: () => CacheState<T, QP, QR, MP, MR>
       /** Apply changes to the entities map.
        * @returns `undefined` if nothing to change, otherwise new `EntitiesMap<T>` with applied changes. */
       applyEntityChanges: (
         entities: Parameters<typeof applyEntityChanges<T>>[0],
         changes: Parameters<typeof applyEntityChanges<T>>[1]
-      ) => import('./types').EntitiesMap<T> | undefined
+      ) => EntitiesMap<T> | undefined
     }
   }
 }
+
 /**
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
@@ -357,12 +353,12 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
   partialCache: Partial<{
     queries: Partial<{
       [QK in keyof (QP & QR)]: QK extends keyof QP & keyof QR
-        ? import('./types').QueryInfo<N, Typenames, QP[QK], QR[QK], QP, QR, MP, MR>
+        ? QueryInfo<N, Typenames, QP[QK], QR[QK], QP, QR, MP, MR>
         : never
     }>
     mutations: Partial<{
       [MK in keyof (MP & MR)]: MK extends keyof MP & keyof MR
-        ? import('./types').MutationInfo<N, Typenames, MP[MK], MR[MK], QP, QR, MP, MR>
+        ? MutationInfo<N, Typenames, MP[MK], MR[MK], QP, QR, MP, MR>
         : never
     }>
     options: Partial<CacheOptions>
@@ -370,7 +366,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       useStore: () => Store
       useSelector: <R>(selector: (state: unknown) => R, comparer?: (x: R, y: R) => boolean) => R
     }>
-    cacheStateSelector: Partial<(state: any) => import('./types').CacheState<Typenames, QP, QR, MP, MR>>
+    cacheStateSelector: Partial<(state: any) => CacheState<Typenames, QP, QR, MP, MR>>
   }> &
     Omit<
       Omit<Cache<N, Typenames, QP, QR, MP, MR>, 'globals'>,
@@ -383,32 +379,26 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
   cache: Cache<N, Typenames, QP, QR, MP, MR>
   /** Reducer of the cache, should be added to redux store. */
   reducer: (
-    state: import('./types').CacheState<Typenames, QP, QR, MP, MR> | undefined,
+    state: CacheState<Typenames, QP, QR, MP, MR> | undefined,
     action:
       | {
           type: `@rrc/${N}/updateQueryStateAndEntities`
           queryKey: keyof QP & keyof QR
           queryCacheKey: Key
-          state:
-            | Partial<
-                import('./types').QueryState<Typenames, QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>
-              >
-            | undefined
-          entityChanges: import('./types').EntityChanges<Typenames> | undefined
+          state: Partial<QueryState<Typenames, QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined
+          entityChanges: EntityChanges<Typenames> | undefined
         }
       | {
           type: `@rrc/${N}/updateMutationStateAndEntities`
           mutationKey: keyof MP & keyof MR
           state:
-            | Partial<
-                import('./types').MutationState<Typenames, MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>
-              >
+            | Partial<MutationState<Typenames, MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>>
             | undefined
-          entityChanges: import('./types').EntityChanges<Typenames> | undefined
+          entityChanges: EntityChanges<Typenames> | undefined
         }
       | {
           type: `@rrc/${N}/mergeEntityChanges`
-          changes: import('./types').EntityChanges<Typenames>
+          changes: EntityChanges<Typenames>
         }
       | {
           type: `@rrc/${N}/invalidateQuery`
@@ -431,23 +421,23 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
         }
       | {
           type: `@rrc/${N}/clearCache`
-          stateToKeep: Partial<import('./types').CacheState<Typenames, QP, QR, MP, MR>> | undefined
+          stateToKeep: Partial<CacheState<Typenames, QP, QR, MP, MR>> | undefined
         }
-  ) => import('./types').CacheState<Typenames, QP, QR, MP, MR>
+  ) => CacheState<Typenames, QP, QR, MP, MR>
   actions: {
     /** 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<import('./types').QueryState<Typenames, QP[K], QR[K]>> | undefined,
-        entityChanges?: import('./types').EntityChanges<Typenames> | undefined
+        state?: Partial<QueryState<Typenames, QP[K], QR[K]>> | undefined,
+        entityChanges?: EntityChanges<Typenames> | undefined
       ): {
         type: `@rrc/${N}/updateQueryStateAndEntities`
         queryKey: K
         queryCacheKey: Key
-        state: Partial<import('./types').QueryState<Typenames, QP[K], QR[K]>> | undefined
-        entityChanges: import('./types').EntityChanges<Typenames> | undefined
+        state: Partial<QueryState<Typenames, QP[K], QR[K]>> | undefined
+        entityChanges: EntityChanges<Typenames> | undefined
       }
       type: `@rrc/${N}/updateQueryStateAndEntities`
     }
@@ -455,21 +445,21 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
     updateMutationStateAndEntities: {
       <K extends keyof MP & keyof MR>(
         mutationKey: K,
-        state?: Partial<import('./types').MutationState<Typenames, MP[K], MR[K]>> | undefined,
-        entityChanges?: import('./types').EntityChanges<Typenames> | undefined
+        state?: Partial<MutationState<Typenames, MP[K], MR[K]>> | undefined,
+        entityChanges?: EntityChanges<Typenames> | undefined
       ): {
         type: `@rrc/${N}/updateMutationStateAndEntities`
         mutationKey: K
-        state: Partial<import('./types').MutationState<Typenames, MP[K], MR[K]>> | undefined
-        entityChanges: import('./types').EntityChanges<Typenames> | undefined
+        state: Partial<MutationState<Typenames, MP[K], MR[K]>> | undefined
+        entityChanges: EntityChanges<Typenames> | undefined
       }
       type: `@rrc/${N}/updateMutationStateAndEntities`
     }
     /** Merges EntityChanges to the state. */
     mergeEntityChanges: {
-      (changes: import('./types').EntityChanges<Typenames>): {
+      (changes: EntityChanges<Typenames>): {
         type: `@rrc/${N}/mergeEntityChanges`
-        changes: import('./types').EntityChanges<Typenames>
+        changes: EntityChanges<Typenames>
       }
       type: `@rrc/${N}/mergeEntityChanges`
     }
@@ -518,22 +508,22 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
     }
     /** Replaces cache state with initial, optionally merging with provided state. Doesn't cancel running fetches and shoult be used with caution. */
     clearCache: {
-      (stateToKeep?: Partial<import('./types').CacheState<Typenames, QP, QR, MP, MR>> | undefined): {
+      (stateToKeep?: Partial<CacheState<Typenames, QP, QR, MP, MR>> | undefined): {
         type: `@rrc/${N}/clearCache`
-        stateToKeep: Partial<import('./types').CacheState<Typenames, QP, QR, MP, MR>> | undefined
+        stateToKeep: Partial<CacheState<Typenames, QP, QR, MP, MR>> | undefined
       }
       type: `@rrc/${N}/clearCache`
     }
   }
   selectors: {
     /** This is a cacheStateSelector from createCache options, or default one if was not provided. */
-    selectCacheState: (state: any) => import('./types').CacheState<Typenames, QP, QR, MP, MR>
+    selectCacheState: (state: any) => CacheState<Typenames, QP, QR, MP, MR>
     /** Selects query state. */
     selectQueryState: <QK_1 extends keyof QP | keyof QR>(
       state: unknown,
       query: QK_1,
       cacheKey: Key
-    ) => import('./types').QueryState<
+    ) => QueryState<
       Typenames,
       QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never,
       QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never
@@ -551,12 +541,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       cacheKey: Key
     ) =>
       | false
-      | Promise<
-          import('./types').NormalizedQueryResponse<
-            Typenames,
-            QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never
-          >
-        >
+      | Promise<NormalizedQueryResponse<Typenames, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>>
     /** Selects query latest error. */
     selectQueryError: <QK_1 extends keyof QP | keyof QR>(
       state: unknown,
@@ -579,7 +564,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
     selectMutationState: <MK_1 extends keyof MP | keyof MR>(
       state: unknown,
       mutation: MK_1
-    ) => import('./types').MutationState<
+    ) => MutationState<
       Typenames,
       MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never,
       MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never
@@ -595,12 +580,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       mutation: MK_1
     ) =>
       | false
-      | Promise<
-          import('./types').NormalizedQueryResponse<
-            Typenames,
-            MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never
-          >
-        >
+      | Promise<NormalizedQueryResponse<Typenames, MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>
     /** Selects mutation latest error. */
     selectMutationError: <MK_1 extends keyof MP | keyof MR>(
       state: unknown,
@@ -618,15 +598,12 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       typename: TN
     ) => object | undefined
     /** Selects all entities. */
-    selectEntities: (state: unknown) => import('./types').EntitiesMap<Typenames>
+    selectEntities: (state: unknown) => EntitiesMap<Typenames>
     /** Selects all entities of provided typename. */
-    selectEntitiesByTypename: <TN extends string>(
-      state: unknown,
-      typename: TN
-    ) => import('./types').Dict<object> | undefined
+    selectEntitiesByTypename: <TN extends string>(state: unknown, typename: TN) => Dict<object> | undefined
   }
   hooks: {
-    /** Returns client object with query and mutate functions. */
+    /** Returns memoized object with query and mutate functions. Memoization dependency is the store. */
     useClient: () => {
       query: <QK_1 extends keyof QP | keyof QR>(
         options: QueryOptions<N, Typenames, QP, QR, QK_1, MP, MR>
@@ -635,12 +612,12 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
         options: MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>
       ) => Promise<MutationResult<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>
     }
-    /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
+    /** Fetches query when params change and subscribes to query state changes (subscription depends on `selectorComparer`). */
     useQuery: <QK_1 extends keyof QP | keyof QR>(
-      options: import('./types').UseQueryOptions<N, Typenames, QK_1, QP, QR, MP, MR>
+      options: UseQueryOptions<N, Typenames, QK_1, QP, QR, MP, MR>
     ) => readonly [
       Omit<
-        import('./types').QueryState<
+        QueryState<
           Typenames,
           QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never,
           QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never
@@ -680,7 +657,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
             : never
         >
       >,
-      import('./types').MutationState<
+      MutationState<
         Typenames,
         MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never,
         MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never
@@ -701,12 +678,12 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       ) => Promise<MutationResult<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>
     }
     /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
-    getInitialState: () => import('./types').CacheState<Typenames, QP, QR, MP, MR>
+    getInitialState: () => CacheState<Typenames, QP, QR, MP, MR>
     /** Apply changes to the entities map.
      * @returns `undefined` if nothing to change, otherwise new `EntitiesMap<T>` with applied changes. */
     applyEntityChanges: (
-      entities: import('./types').EntitiesMap<Typenames>,
-      changes: import('./types').EntityChanges<Typenames>
-    ) => import('./types').EntitiesMap<Typenames> | undefined
+      entities: EntitiesMap<Typenames>,
+      changes: EntityChanges<Typenames>
+    ) => EntitiesMap<Typenames> | undefined
   }
 }

package/dist/types/{createCacheReducer.d.ts → createReducer.d.ts}

@@ -1,7 +1,7 @@
 import type {Actions} from './createActions'
 import type {CacheOptions, CacheState, Typenames} from './types'
 
-export declare const createCacheReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(
+export declare const createReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(
   actions: Actions<N, T, QP, QR, MP, MR>,
   queryKeys: (keyof (QP | QR))[],
   cacheOptions: CacheOptions

package/dist/types/createSelectors.d.ts

@@ -8,6 +8,7 @@ export type Selectors<
   MP = unknown,
   MR = unknown
 > = ReturnType<typeof createSelectors<N, T, QP, QR, MP, MR>>
+
 export declare const createSelectors: <N extends string, T extends Typenames, QP, QR, MP, MR>(
   cache: Cache<N, T, QP, QR, MP, MR>
 ) => {

package/dist/types/index.d.ts

@@ -1,3 +1,5 @@
 export {createCache, withTypenames} from './createCache'
+
 export * from './types'
+
 export {createStateComparer, defaultGetCacheKey, FetchPolicy, isEmptyObject} from './utilsAndConstants'

package/dist/types/mutate.d.ts

@@ -13,7 +13,7 @@ export declare const mutate: <
 >(
   logTag: string,
   store: Store,
-  cache: Cache<N, T, QP, QR, MP, MR>,
+  cache: Pick<Cache<N, T, QP, QR, MP, MR>, 'options' | 'globals' | 'mutations'>,
   actions: Actions<N, T, QP, QR, MP, MR>,
   selectors: Selectors<N, T, QP, QR, MP, MR>,
   mutationKey: MK,

package/dist/types/query.d.ts

@@ -13,7 +13,7 @@ export declare const query: <
 >(
   logTag: string,
   store: Store,
-  cache: Cache<N, T, QP, QR, MP, MR>,
+  cache: Pick<Cache<N, T, QP, QR, MP, MR>, 'options' | 'globals' | 'queries'>,
   actions: Actions<N, T, QP, QR, MP, MR>,
   selectors: Selectors<N, T, QP, QR, MP, MR>,
   queryKey: QK,
@@ -21,6 +21,7 @@ export declare const query: <
   params: QK extends keyof (QP | QR) ? QP[QK] : never,
   secondsToLive: number | undefined,
   onlyIfExpired: boolean | undefined,
+  skipFetch: boolean | undefined,
   mergeResults?:
     | ((
         oldResult: QR[keyof QP & keyof QR & string] | undefined,

package/dist/types/types.d.ts

@@ -2,11 +2,14 @@ import type {Actions} from './createActions'
 import type {Selectors} from './createSelectors'
 
 export type Key = string | number | symbol
+
 export type Dict<T> = Record<Key, T>
+
 export type OptionalPartial<T, K extends keyof T> = Partial<{
   [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. */
@@ -18,12 +21,15 @@ export type EntityChanges<T extends Typenames> = {
   /** Alias for `merge` to support normalizr. */
   entities?: EntityChanges<T>['merge']
 }
+
 export type Store<S = unknown> = {
   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 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
@@ -51,10 +57,12 @@ export type Cache<N extends string, T extends Typenames, 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?: (
@@ -85,6 +93,7 @@ export type Globals<N extends string, T extends Typenames, QP, QR, MP, MR> = {
     selectorComparer?: QueryStateComparer<T, unknown, unknown> | (keyof QueryState<T, unknown, unknown>)[]
   }
 }
+
 export type CacheOptions = {
   /** Enables additional validation with logging to console.warn. Recommened to enable in dev/testing mode. @Default true in dev mode. */
   additionalValidation: boolean
@@ -98,15 +107,19 @@ export type CacheOptions = {
    */
   deepComparisonEnabled: boolean
 }
+
 export type PartialEntitiesMap<T extends Typenames> = {
   [K in keyof T]?: Dict<Partial<T[K]>>
 }
+
 export type EntitiesMap<T extends Typenames> = {
   [K in keyof T]?: Dict<T[K]>
 }
+
 export type EntityIds<T extends Typenames> = {
   [K in keyof T]?: Key[]
 }
+
 export type CacheState<T extends Typenames, QP, QR, MP, MR> = {
   entities: EntitiesMap<T>
   queries: {
@@ -116,6 +129,7 @@ export type CacheState<T extends Typenames, QP, QR, MP, MR> = {
     [MK in keyof (MP | MR)]: MutationState<T, MP[MK], MR[MK]>
   }
 }
+
 export type QueryInfo<
   N extends string,
   T extends Typenames = Typenames,
@@ -180,15 +194,18 @@ export type QueryInfo<
   /** 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>>
+
 export type QueryState<T extends Typenames, P, R> = MutationState<T, P, R> & {
   /**
    * Timestamp in milliseconds, after which state is considered expired.
@@ -197,6 +214,7 @@ export type QueryState<T extends Typenames, P, R> = MutationState<T, P, R> & {
    * */
   expiresAt?: number
 }
+
 export type UseQueryOptions<
   N extends string,
   T extends Typenames,
@@ -228,6 +246,7 @@ export type UseQueryOptions<
   | 'onSuccess'
   | 'onError'
 >
+
 export type QueryOptions<
   N extends string,
   T extends Typenames,
@@ -236,23 +255,37 @@ export type QueryOptions<
   QK extends keyof (QP & QR),
   MP,
   MR
-> = Omit<UseQueryOptions<N, T, QK, QP, QR, MP, MR>, 'skipFetch'> & {
+> = 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 for query state, ignoring `secondsToLive`. */
   expiresAt?: number
 }
+
 export type NormalizedQueryResponse<T extends Typenames = Typenames, R = unknown> = EntityChanges<T> &
   QueryResponse<R>
+
 export type QueryResult<R = unknown> = {
   error?: unknown
   /** Fetch cancelled reason. */
   cancelled?: 'loading' | 'not-expired'
   result?: R
 }
+
 export type MutationInfo<
   N extends string,
   T extends Typenames = Typenames,
@@ -265,6 +298,7 @@ export type MutationInfo<
 > = 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,
@@ -273,9 +307,11 @@ export type Mutation<P = unknown, R = unknown> = (
   /** 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,
@@ -300,16 +336,20 @@ export type MutateOptions<
   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>
+
 export type MutationResult<R = unknown> = {
   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>>

package/dist/types/useMutation.d.ts

@@ -11,7 +11,7 @@ export declare const useMutation: <
   MR,
   MK extends keyof (MP & MR)
 >(
-  cache: Cache<N, T, QP, QR, 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'>,

package/dist/types/useQuery.d.ts

@@ -11,7 +11,7 @@ export declare const useQuery: <
   MR,
   QK extends keyof (QP & QR)
 >(
-  cache: Cache<N, T, QP, QR, MP, MR>,
+  cache: Pick<Cache<N, T, QP, QR, MP, MR>, 'options' | 'globals' | 'queries' | 'storeHooks'>,
   actions: Actions<N, T, QP, QR, MP, MR>,
   selectors: Selectors<N, T, QP, QR, MP, MR>,
   options: UseQueryOptions<N, T, QK, QP, QR, MP, MR>

package/dist/types/utilsAndConstants.d.ts

@@ -9,31 +9,45 @@ import type {
 } from './types'
 
 export declare const PACKAGE_SHORT_NAME = 'rrc'
+
 export declare const optionalUtils: {
   deepEqual?: (a: any, b: any) => boolean
 }
+
 export declare const IS_DEV: boolean
+
 export declare const EMPTY_OBJECT: Readonly<{}>
+
 export declare const EMPTY_ARRAY: readonly never[]
+
 export declare const NOOP: () => void
+
+/** Default getCacheKey implementation. */
 export declare const defaultGetCacheKey: <P = unknown>(params: P) => Key
+
 export declare const log: (tag: string, data?: unknown) => void
-export declare const FetchPolicy: {
-  /** Only if cache does not exist (result is undefined) or expired. */
-  NoCacheOrExpired: <T extends Typenames = Typenames, P = unknown, R = unknown>(
-    expired: boolean,
-    _params: P,
-    state: QueryState<T, P, R>
-  ) => boolean
-  /** Every fetch trigger. */
-  Always: () => boolean
-}
+
 export declare const applyEntityChanges: <T extends Typenames>(
   entities: EntitiesMap<T>,
   changes: EntityChanges<T>,
   options: CacheOptions
 ) => EntitiesMap<T> | undefined
+
+/** Returns true if object has no keys. */
 export declare const isEmptyObject: (o: object) => boolean
+
+/** Returns query state comparer that compares only provided fields. Used in implementation of `selectorComparer` option. */
 export declare const createStateComparer: <T extends Typenames = Typenames, Q = unknown, P = unknown>(
   fields: (keyof QueryState<T, Q, P>)[]
 ) => QueryStateComparer<T, Q, P>
+
+export declare const FetchPolicy: {
+  /** Only if cache does not exist (result is undefined) or expired. @Default */
+  NoCacheOrExpired: <T extends Typenames = Typenames, P = unknown, R = unknown>(
+    expired: boolean,
+    _params: P,
+    state: QueryState<T, P, R>
+  ) => boolean
+  /** Every fetch trigger. */
+  Always: () => boolean
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.19.4",
+  "version": "0.19.6",
   "description": "Powerful data fetching and caching library for Redux and Zustand that supports normalization.",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -23,14 +23,15 @@
     "build-cjs": "tsc -p tsconfig.cjs.json && rm -rf dist/cjs/testing && rm -rf dist/cjs/__tests__",
     "build-esm": "tsc -p tsconfig.esm.json > /dev/null ; rm -rf dist/esm/testing && rm -rf dist/esm/__tests__",
     "build-types": "tsc -p tsconfig.types.json > /dev/null ; rm -rf dist/types/testing && rm -rf dist/types/__tests__",
-    "build": "yarn clean && yarn lint && yarn build-cjs && yarn build-esm && yarn build-types && yarn size && yarn lint-fix-dist",
+    "build": "yarn clean && yarn lint && yarn build-cjs && yarn build-esm && yarn build-types && yarn size && yarn lint-fix-dist && yarn generate-docs",
     "size": "npx minified-size dist/esm/*.js | grep 'total:' | sed -E 's/.*total: [^,]*, ([^,]*), ([^,]*), ([^,]*).*/<br\\/>minified: \\1<br\\/>gzipped: \\2<br\\/>brotlied: \\3/'",
     "test": "node node_modules/jest/bin/jest.js",
     "preminor-rc": "yarn build && npm version preminor --preid rc",
     "prepatch-rc": "yarn build && npm version prepatch --preid rc",
     "publish-rc": "npm publish --tag rc",
     "remove-rc": "npm version <same-version-without-rc>",
-    "prepublishOnly": "yarn build && yarn test"
+    "prepublishOnly": "yarn build && yarn test",
+    "generate-docs": "node --experimental-strip-types scripts/generate-docs.ts"
   },
   "peerDependencies": {
     "fast-deep-equal": "*",