react-redux-cache 0.12.0 → 0.13.0

package/dist/types.d.ts

@@ -1,5 +1,7 @@
-import { Store } from 'redux';
+import type { Store } from 'redux';
+import type { Actions } from './createActions';
 import type { ReduxCacheState } from './createCacheReducer';
+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<{
@@ -22,48 +24,42 @@ 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 redux state. */
     name: N;
     queries: {
-        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK]> : never;
+        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<N, T, QP[QK], QR[QK], QP, QR, MP, MR> : never;
     };
     mutations: {
-        [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<T, MP[MK], MR[MK]> : never;
+        [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<N, T, MP[MK], MR[MK], QP, QR, MP, MR> : never;
     };
-    /** Default options for queries and mutations.
-     * @default { cachePolicy: 'cache-first', sedondsToLive: undefined, onError: undefined } */
-    globals: Globals<QP, MP>;
+    /** Default options for queries and mutations. */
+    globals: Globals<N, T, QP, QR, MP, MR>;
     options: CacheOptions;
     /** Should return cache state from redux root state. Default implementation returns `state[name]`. */
     cacheStateSelector: (state: any) => ReduxCacheState<T, QP, QR, MP, MR>;
 };
-export type Globals<QP, MP> = {
-    /**
-     * Cache policy.
-     * @cache-first fetch only if cache either does not exist or is expired on useQuery mount.
-     * @cache-and-fetch fetch on every useQuery mount.
-     * @default cache-first
-     */
-    cachePolicy: QueryCachePolicy;
-    /** If set, this value updates expiresAt value of query state when query result is received. */
-    secondsToLive?: number;
-    /** Handles errors, not handled by onError from queries and mutations. */
-    onError?: <K extends keyof QP | keyof MP>(error: unknown, key: K, params: QP[keyof QP] | MP[keyof MP], // TODO proper type
-    store: Store) => void;
+export type Globals<N extends string, T extends Typenames, QP, QR, MP, MR> = {
+    /** Handles errors, not handled by onError from queries and mutations. @Default undefined. */
+    onError?: (error: unknown, key: string, params: unknown, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void;
+    /** Query options. */
+    queries: {
+        /** Determines when useQuery fetch triggers should start fetching. Fetch is performed if function returns true.
+         * Fetch triggers are: 1) mount 2) cache key change 3) skipFetch value change to false.
+         * @Default FetchPolicy.NoCacheOrExpired */
+        fetchPolicy: (expired: boolean, params: unknown, state: QueryState<unknown, unknown>, store: Store, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean;
+        /** Disables any fetches when set to true. Triggers fetch when changed to false. @Default false */
+        skipFetch: boolean;
+        /** If set, this value updates expiresAt value of query state when query result is received. @Default undefined */
+        secondsToLive?: number;
+    };
 };
 export type CacheOptions = {
-    /**
-     * Enables additional validation with logging to console.warn. Recommened to enable in dev/testing mode.
-     * @default true in dev mode.
-     * */
+    /** Enables additional validation with logging to console.warn. Recommened to enable in dev/testing mode. @Default true in dev mode. */
     additionalValidation: boolean;
-    /**
-     * Enables debug logs.
-     * @default false
-     */
+    /** Enables debug logs. @Default false */
     logsEnabled: boolean;
     /**
      * Enables deep comparison before merging entities to the state.
      * Re-rendering is a heavier operation than comparison, so disabling it can lead to performance drop.
      * Makes sense to disable only if merging equal results & entities to the state is a rare case.
-     * @default true
+     * @Default true
      */
     deepComparisonEnabled: boolean;
 };
@@ -76,22 +72,26 @@ export type EntitiesMap<T extends Typenames> = {
 export type EntityIds<T extends Typenames> = {
     [K in keyof T]?: Key[];
 };
-export type QueryInfo<T extends Typenames = Typenames, P = unknown, R = unknown> = Partial<Pick<Globals<unknown, unknown>, 'cachePolicy' | 'secondsToLive'>> & {
+export type QueryInfo<N extends string, T extends Typenames = Typenames, P = unknown, R = unknown, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = Partial<Pick<Globals<N, T, QP, QR, MP, MR>['queries'], 'skipFetch' | 'secondsToLive'>> & {
     query: NormalizedQuery<T, P, R>;
+    /** Determines when useQuery fetch triggers should start fetching. Fetch is performed if function returns true.
+     * Fetch triggers are: 1) mount 2) cache key change 3) skipFetch value change to false.
+     * @Default FetchPolicy.NoCacheOrExpired */
+    fetchPolicy?: (expired: boolean, params: P, queryState: QueryState<P, R>, store: Store, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean;
     /** Merges results before saving to the store. Default implementation is using the latest result. */
-    mergeResults?: (oldResult: R | undefined, response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store) => R;
+    mergeResults?: (oldResult: R | undefined, response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => R;
     /**
      * Cache key is used for storing the query state and for performing a fetch when it changes. Queries with the same cache key share their state.
-     * Default implementation uses `JSON.stringify` or `String()` depending on type.
+     * Default implementation uses `String()` or `JSON.stringify` depending on type.
      * It is recommended to override it when default implementation is not optimal or when keys in params object can be sorted in random order etc.
-     * */
+     */
     getCacheKey?: (params?: P) => Key;
-    /** Called after fetch finished either successfully or not. */
-    onCompleted?: (response: NormalizedQueryResponse<T, R> | undefined, error: unknown | undefined, params: P | undefined, store: Store) => void;
-    /** Called after fetch finished without error. */
-    onSuccess?: (response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store) => void;
+    /** Called after fetch completed either successfully or not. */
+    onCompleted?: (response: NormalizedQueryResponse<T, R> | undefined, error: unknown | undefined, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void;
+    /** Called after fetch finished successfully. */
+    onSuccess?: (response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void;
     /** Called after fetch finished with error. Should return true if error was handled and does not require global onError handling. */
-    onError?: (error: unknown, params: P | undefined, store: Store) => boolean | void | null | undefined;
+    onError?: (error: unknown, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined;
 };
 export type Query<P = unknown, R = unknown> = (
 /** Query parameters */
@@ -102,17 +102,14 @@ export type NormalizedQuery<T extends Typenames = Typenames, P = unknown, R = un
 export type QueryState<P, R> = MutationState<P, R> & {
     expiresAt?: number;
 };
-export type UseQueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)> = {
+export type UseQueryOptions<N extends string, T extends Typenames, QK extends keyof (QP & QR), QP, QR, MP, MR> = {
     query: QK;
     params: QK extends keyof (QP | QR) ? QP[QK] : never;
-    /** When true fetch is not performed. When switches to false fetch is performed depending on cache policy. */
-    skip?: boolean;
-} & Pick<QueryInfo<T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never>, 'cachePolicy' | 'secondsToLive' | 'mergeResults' | 'onCompleted' | 'onSuccess' | 'onError'>;
-export type QueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, QK>, 'skip' | 'cachePolicy'> & {
+} & Pick<QueryInfo<N, T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never, QP, QR, MP, MR>, 'fetchPolicy' | 'skipFetch' | 'secondsToLive' | 'mergeResults' | 'onCompleted' | 'onSuccess' | 'onError'>;
+export type QueryOptions<N extends string, T extends Typenames, QP, QR, QK extends keyof (QP & QR), MP, MR> = Omit<UseQueryOptions<N, T, QK, QP, QR, MP, MR>, 'skipFetch'> & {
     /** If set to true, query will run only if it is expired or result not yet cached. */
     onlyIfExpired?: boolean;
 };
-export type QueryCachePolicy = 'cache-first' | 'cache-and-fetch';
 export type QueryResponse<R = unknown> = {
     result: R;
     /** If defined, overrides this value for query state, ignoring `secondsToLive`. */
@@ -124,7 +121,7 @@ export type QueryResult<R = unknown> = {
     cancelled?: true;
     result?: R;
 };
-export type MutationInfo<T extends Typenames = Typenames, P = unknown, R = unknown> = Pick<QueryInfo<T, P, R>, 'onCompleted' | 'onSuccess' | 'onError'> & {
+export type MutationInfo<N extends string, T extends Typenames = Typenames, P = unknown, R = unknown, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = Pick<QueryInfo<N, T, P, R, QP, QR, MP, MR>, 'onCompleted' | 'onSuccess' | 'onError'> & {
     mutation: NormalizedMutation<T, P, R>;
 };
 export type Mutation<P = unknown, R = unknown> = (
@@ -135,7 +132,7 @@ store: Store,
 /** Signal is aborted for current mutation when the same mutation was called once again. */
 abortSignal: AbortSignal) => Promise<MutationResponse<R>>;
 export type NormalizedMutation<T extends Typenames = Typenames, P = unknown, R = unknown> = (...args: Parameters<Mutation<P, R>>) => Promise<NormalizedMutationResponse<T, R>>;
-export type MutateOptions<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'> & {
+export type MutateOptions<N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)> = Pick<MutationInfo<N, T, MK extends keyof (MP | MR) ? MP[MK] : never, MK extends keyof (MP | MR) ? MR[MK] : never, QP, QR, MP, MR>, 'onCompleted' | 'onSuccess' | 'onError'> & {
     mutation: MK;
     params: MK extends keyof (MP | MR) ? MP[MK] : never;
 };

package/dist/useMutation.d.ts

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

package/dist/useMutation.js

@@ -14,7 +14,7 @@ const react_1 = require("react");
 const react_redux_1 = require("react-redux");
 const mutate_1 = require("./mutate");
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const useMutation = (cache, actions, options, abortControllers) => {
+const useMutation = (cache, actions, selectors, options, abortControllers) => {
     var _a;
     const { mutation: mutationKey, onCompleted, onSuccess, onError } = options;
     const store = (0, react_redux_1.useStore)();
@@ -32,7 +32,7 @@ const useMutation = (cache, actions, options, abortControllers) => {
             },
             // mutate
             (params) => __awaiter(void 0, void 0, void 0, function* () {
-                return yield (0, mutate_1.mutate)('useMutation.mutate', store, cache, actions, mutationKey, params, abortControllers, 
+                return yield (0, mutate_1.mutate)('useMutation.mutate', store, cache, actions, selectors, mutationKey, params, abortControllers, 
                 // @ts-expect-error fix later
                 onCompleted, onSuccess, onError);
             }),

package/dist/useQuery.d.ts

@@ -1,3 +1,6 @@
-import { ActionMap } from './createActions';
+import { Actions } from './createActions';
+import { Selectors } from './createSelectors';
 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 & 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>>];
+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: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, options: UseQueryOptions<N, T, QK, QP, QR, MP, MR>) => 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<N, T, QP, QR, QK, MP, MR>, "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>>];
+/** Omit `expiresAt` from comparison */
+export declare const useQuerySelectorStateComparer: <P, R>(state1: QueryState<P, R> | undefined, state2: QueryState<P, R> | undefined) => boolean;

package/dist/useQuery.js

@@ -9,14 +9,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useQuery = void 0;
+exports.useQuerySelectorStateComparer = exports.useQuery = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
 const query_1 = require("./query");
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const useQuery = (cache, actions, options) => {
+const useQuery = (cache, actions, selectors, options) => {
     var _a, _b, _c;
-    const { query: queryKey, skip, params, secondsToLive, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : cache.globals.cachePolicy, mergeResults, onCompleted, onSuccess, onError, } = options;
+    const { query: queryKey, skipFetch = false, params, secondsToLive, fetchPolicy = (_a = cache.queries[queryKey].fetchPolicy) !== null && _a !== void 0 ? _a : cache.globals.queries.fetchPolicy, mergeResults, onCompleted, onSuccess, onError, } = options;
     const logsEnabled = cache.options.logsEnabled;
     const getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
     const cacheStateSelector = cache.cacheStateSelector;
@@ -26,7 +26,7 @@ const useQuery = (cache, actions, options) => {
     /** Fetch query with the new parameters, or refetch with the same if parameters not provided. */
     const fetch = (0, react_1.useCallback)((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, queryKey, 
+        return yield (0, query_1.query)('useQuery.fetch', store, cache, actions, selectors, queryKey, 
         // @ts-expect-error fix later
         paramsPassed ? getCacheKey(options.params) : cacheKey, paramsPassed ? options.params : params, // params type can also have null | undefined, thats why we don't check for it here
         secondsToLive, options === null || options === void 0 ? void 0 : options.onlyIfExpired, 
@@ -39,27 +39,27 @@ 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.EMPTY_OBJECT;
+    }, (exports.useQuerySelectorStateComparer))) !== 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 });
+        if (skipFetch) {
+            logsEnabled && (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch', { skipFetch, queryKey, cacheKey });
             return;
         }
-        if (queryState.result != null &&
-            cachePolicy === 'cache-first' &&
-            (queryState.expiresAt == null || queryState.expiresAt > Date.now())) {
+        const expired = queryState.expiresAt != null && queryState.expiresAt <= Date.now();
+        // @ts-expect-error params
+        if (!fetchPolicy(expired, params, queryState, store, selectors)) {
             logsEnabled &&
-                (0, utilsAndConstants_1.log)('useQuery.useEffect no fetch due to cache policy', {
-                    result: queryState.result,
-                    expiresAt: queryState.expiresAt,
-                    now: Date.now(),
-                    cachePolicy,
+                (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch due to fetch policy', {
+                    queryState,
+                    expired,
+                    queryKey,
+                    cacheKey,
                 });
             return;
         }
         fetch();
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [cacheKey, cachePolicy, skip]);
+    }, [cacheKey, skipFetch]);
     logsEnabled &&
         (0, utilsAndConstants_1.log)('useQuery', {
             cacheKey,
@@ -70,15 +70,16 @@ const useQuery = (cache, actions, options) => {
 };
 exports.useQuery = useQuery;
 /** Omit `expiresAt` from comparison */
-const useQueryStateComparer = (state1, state2) => {
+const useQuerySelectorStateComparer = (state1, state2) => {
     if (state1 === state2) {
         return true;
     }
     if (state1 === undefined || state2 === undefined) {
         return false;
     }
-    return (state1.error === state2.error &&
+    return (state1.params === state2.params &&
         state1.loading === state2.loading &&
-        state1.params === state2.params &&
-        state1.result === state2.result);
+        state1.result === state2.result &&
+        state1.error === state2.error);
 };
+exports.useQuerySelectorStateComparer = useQuerySelectorStateComparer;

package/dist/utilsAndConstants.d.ts

@@ -1,4 +1,4 @@
-import type { CacheOptions, EntitiesMap, EntityChanges, Key, Typenames } from './types';
+import type { CacheOptions, EntitiesMap, EntityChanges, Key, QueryState, Typenames } from './types';
 export declare const PACKAGE_SHORT_NAME = "rrc";
 export declare const optionalUtils: {
     deepEqual?: (a: any, b: any) => boolean;
@@ -8,5 +8,11 @@ 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 FetchPolicy: {
+    /** Only if cache does not exist (result is undefined) or expired. */
+    NoCacheOrExpired: (expired: boolean, _: unknown, state: QueryState<unknown, unknown>) => boolean;
+    /** Every fetch trigger. */
+    Always: () => boolean;
+};
 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.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.isEmptyObject = exports.applyEntityChanges = exports.FetchPolicy = 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,
@@ -38,6 +38,14 @@ const log = (tag, data) => {
     console.debug(`@${exports.PACKAGE_SHORT_NAME} [${tag}]`, data);
 };
 exports.log = log;
+exports.FetchPolicy = {
+    /** Only if cache does not exist (result is undefined) or expired. */
+    NoCacheOrExpired: (expired, _, state) => {
+        return expired || state.result === undefined;
+    },
+    /** Every fetch trigger. */
+    Always: () => true,
+};
 const applyEntityChanges = (entities, changes, options) => {
     var _a, _b, _c, _d;
     if (changes.merge && changes.entities) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.12.0",
+  "version": "0.13.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",
@@ -10,7 +10,7 @@
     "example": "(cd example && yarn && yarn start)",
     "clean": "rm -rf dist",
     "lint": "yarn eslint src",
-    "build": "yarn clean && yarn lint && tsc",
+    "build": "yarn clean && yarn lint && tsc && rm -rf dist/testing && rm -rf dist/__tests__",
     "test": "node node_modules/jest/bin/jest.js",
     "preminor-rc": "yarn build && npm version preminor --preid rc",
     "publish-rc": "npm publish --tag rc",