react-redux-cache 0.0.6 → 0.0.8

package/dist/createCache.d.ts

@@ -1,5 +1,5 @@
 import { mergeEntityChanges, setMutationStateAndEntities, setQueryStateAndEntities } from './reducer';
-import { Cache, EntitiesMap, Key, OptionalPartial, Typenames } from './types';
+import { Cache, EntitiesMap, Key, OptionalPartial, QueryOptions, Typenames } from './types';
 import { useMutation } from './useMutation';
 import { useQuery } from './useQuery';
 /**
@@ -58,10 +58,16 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
         entitiesByTypenameSelector: <TN extends keyof T>(typename: TN) => { [K_2 in keyof T]: (state: unknown) => EntitiesMap<T>[K_2]; }[TN];
     };
     hooks: {
+        useClient: () => {
+            query: <QK_1 extends keyof QP | keyof QR>(options: QueryOptions<T, QP, QR, MP, MR, QK_1>) => Promise<void | import("./types").QueryResult<QK_1 extends infer T_1 ? T_1 extends QK_1 ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>;
+        };
         /** Fetches query when params change and subscribes to query state. */
-        useQuery: <QK_1 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, MP, MR, QK_1>) => readonly [import("./types").QueryMutationState<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>, (params?: (QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never) | undefined) => Promise<void>];
+        useQuery: <QK_2 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, MP, MR, QK_2>) => readonly [import("./types").QueryMutationState<QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never>, () => Promise<void | import("./types").QueryResult<QK_2 extends infer T_2 ? T_2 extends QK_2 ? T_2 extends keyof QP & keyof QR ? QR[T_2] : never : never : never>>];
         /** Subscribes to provided mutation state and provides mutate function. */
         useMutation: <MK_1 extends keyof MP | keyof MR>(options: {
+            /**
+             * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
+             */
             mutation: MK_1;
             cacheOptions?: import("./types").MutationCacheOptions | undefined;
         }) => readonly [(params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never) => Promise<void>, import("./types").QueryMutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never>, AbortController | undefined];

package/dist/createCache.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCache = void 0;
+const react_1 = require("react");
 const react_redux_1 = require("react-redux");
+const query_1 = require("./query");
 const reducer_1 = require("./reducer");
 const useMutation_1 = require("./useMutation");
 const useQuery_1 = require("./useQuery");
@@ -15,12 +17,18 @@ const createCache = (cache) => {
     // @ts-expect-error hot
     const hotReloadEnabled = Boolean(module === null || module === void 0 ? void 0 : module.hot);
     // provide all optional fields
+    // and transform cacheOptions from QueryCachePolicy to QueryCacheOptions
     (_a = cache.options) !== null && _a !== void 0 ? _a : (cache.options = {});
     (_b = (_g = cache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_g.logsEnabled = false);
     (_c = (_h = cache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_h.validateFunctionArguments = utilsAndConstants_1.isDev);
     (_d = (_j = cache.options).validateHookArguments) !== null && _d !== void 0 ? _d : (_j.validateHookArguments = utilsAndConstants_1.isDev && !hotReloadEnabled);
     (_e = cache.queries) !== null && _e !== void 0 ? _e : (cache.queries = {});
     (_f = cache.mutations) !== null && _f !== void 0 ? _f : (cache.mutations = {});
+    for (const queryInfo of Object.values(cache.queries)) {
+        if (typeof queryInfo.cacheOptions === 'string') {
+            queryInfo.cacheOptions = useQuery_1.queryCacheOptionsByPolicy[queryInfo.cacheOptions];
+        }
+    }
     const nonPartialCache = cache;
     // make selectors
     const entitiesSelector = (state) => {
@@ -49,6 +57,30 @@ const createCache = (cache) => {
             },
         },
         hooks: {
+            useClient: () => {
+                const store = (0, react_redux_1.useStore)();
+                return (0, react_1.useMemo)(() => {
+                    const client = {
+                        query: (options) => {
+                            var _a, _b;
+                            const { query: queryKey, params, 
+                            // TODO can be memoized for all query keys while creating cache
+                            cacheOptions: cacheOptionsOrPolicy = Object.assign(Object.assign({}, ((_a = nonPartialCache.queries[queryKey].cacheOptions) !== null && _a !== void 0 ? _a : useQuery_1.defaultQueryCacheOptions)), { policy: 'cache-and-fetch' }), getCacheKey = nonPartialCache.queries[queryKey].getCacheKey, } = options;
+                            const cacheOptions = typeof cacheOptionsOrPolicy === 'string'
+                                ? useQuery_1.queryCacheOptionsByPolicy[cacheOptionsOrPolicy]
+                                : cacheOptionsOrPolicy;
+                            const getParamsKey = (_b = nonPartialCache.queries[queryKey].getParamsKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetParamsKey);
+                            const cacheKey = getCacheKey
+                                ? // @ts-expect-error fix later
+                                    getCacheKey(params)
+                                : // @ts-expect-error fix later
+                                    getParamsKey(params);
+                            return (0, query_1.query)('query', true, store, nonPartialCache, queryKey, cacheKey, cacheOptions, params);
+                        },
+                    };
+                    return client;
+                }, [store]);
+            },
             /** Fetches query when params change and subscribes to query state. */
             useQuery: (options) => (0, useQuery_1.useQuery)(nonPartialCache, options),
             /** Subscribes to provided mutation state and provides mutate function. */

package/dist/index.js

@@ -31,6 +31,8 @@ Object.defineProperty(exports, "processEntityChanges", { enumerable: true, get:
 // Backlog
 // ! high
 // cover with tests
+// support changing query key?
+// make cache fields readonly
 // ! medium
 // type extractors from cache
 // custom useStore
@@ -65,4 +67,4 @@ Object.defineProperty(exports, "processEntityChanges", { enumerable: true, get:
 // QueryInfo.defaultOptions
 // set options in refresh/mutate functions
 // multiple reducers instead of 1?
-// don't cache result if resultSelector set?
+// don't cache result if resultSelector set? throw error if mergeResult set with resultSelector?

package/dist/query.d.ts

@@ -0,0 +1,3 @@
+import { Store } from 'redux';
+import { Cache, Key, QueryCacheOptions, QueryResult, Typenames } from './types';
+export declare const query: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(logTag: string, returnResult: boolean, store: Store, cache: Cache<T, QP, QR, MP, MR>, queryKey: QK, cacheKey: Key, cacheOptions: QueryCacheOptions, params: QK extends keyof QP & keyof QR ? QP[QK] : never) => Promise<void | QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;

package/dist/query.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.query = void 0;
+const reducer_1 = require("./reducer");
+const utilsAndConstants_1 = require("./utilsAndConstants");
+const query = (logTag, returnResult, store, cache, queryKey, cacheKey, cacheOptions, params) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const logsEnabled = cache.options.logsEnabled;
+    const cacheStateSelector = cache.cacheStateSelector;
+    const cacheResultSelector = cache.queries[queryKey].resultSelector;
+    const mergeResults = cache.queries[queryKey].mergeResults;
+    const queryStateOnStart = cacheStateSelector(store.getState()).queries[queryKey][cacheKey];
+    if (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.loading) {
+        logsEnabled &&
+            (0, utilsAndConstants_1.log)(`${logTag} cancel: already loading`, {
+                queryStateOnStart,
+                params,
+                cacheKey,
+            });
+        return returnResult ? { cancelled: true } : undefined;
+    }
+    cacheOptions.cacheQueryState &&
+        store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
+            loading: true,
+        }));
+    logsEnabled && (0, utilsAndConstants_1.log)(`${logTag} started`, { queryStateOnStart, params, cacheKey });
+    let response;
+    const fetchFn = cache.queries[queryKey].query;
+    try {
+        response = yield fetchFn(
+        // @ts-expect-error fix later
+        params);
+    }
+    catch (error) {
+        store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
+            error: error,
+            loading: false,
+        }));
+        return returnResult ? { error } : undefined;
+    }
+    const newState = cacheOptions.cacheQueryState
+        ? {
+            error: undefined,
+            loading: false,
+            result: cacheResultSelector
+                ? undefined
+                : mergeResults
+                    ? mergeResults(
+                    // @ts-expect-error fix later
+                    (_a = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _a === void 0 ? void 0 : _a.result, response, params)
+                    : response.result,
+        }
+        : undefined;
+    store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, newState, cacheOptions.cacheEntities ? response : undefined));
+    // @ts-expect-error fix types
+    return returnResult
+        ? {
+            result: cacheResultSelector
+                ? cacheResultSelector(cacheStateSelector(store.getState()), 
+                // @ts-expect-error fix types
+                params)
+                : newState === null || newState === void 0 ? void 0 : newState.result,
+        }
+        : undefined;
+});
+exports.query = query;

package/dist/types.d.ts

@@ -60,7 +60,7 @@ export type Query<T extends Typenames, P, R> = (params: P) => Promise<QueryRespo
 export type QueryInfo<T extends Typenames, P, R, S> = {
     query: Query<T, P, R>;
     /**
-     * Cache policy string or cache options object.
+     * Cache policy string or cache options object. After cache created, all strings are converted to objects.
      * Default is { policy: 'cache-first', cacheQueryState: true, cacheEntities: true }
      * @param cache-first for each params key fetch is not called if cache exists.
      * @param cache-and-fetch for each params key result is taken from cache and fetch is called.
@@ -112,6 +112,12 @@ export type QueryResponse<T extends Typenames, R> = EntityChanges<T> & {
     /** Normalized result of a query. */
     result: R;
 };
+export type QueryResult<R> = {
+    error?: unknown;
+    cancelled?: true;
+    result?: R;
+};
+export type QueryOptions<T extends Typenames, QP, QR, MP, MR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, MP, MR, QK>, 'skip'>;
 export type Mutation<T extends Typenames, P, R> = (params: P, 
 /** Signal is aborted for current mutation when the same mutation was called once again. */
 abortSignal: AbortSignal) => Promise<MutationResponse<T, R>>;

package/dist/useQuery.d.ts

@@ -5,4 +5,4 @@ export declare const defaultQueryCacheOptions: {
     readonly cacheQueryState: true;
     readonly cacheEntities: true;
 };
-export declare const useQuery: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<T, QP, QR, MP, MR>, options: UseQueryOptions<T, QP, QR, MP, MR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QR[QK] : never>, (params?: (QK extends keyof QP & keyof QR ? QP[QK] : never) | undefined) => Promise<void>];
+export declare const useQuery: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<T, QP, QR, MP, MR>, options: UseQueryOptions<T, QP, QR, MP, MR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QR[QK] : never>, () => Promise<void | 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

@@ -1,18 +1,9 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useQuery = exports.defaultQueryCacheOptions = exports.queryCacheOptionsByPolicy = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
-const reducer_1 = require("./reducer");
+const query_1 = require("./query");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const cacheFirstOptions = {
     policy: 'cache-first',
@@ -24,14 +15,13 @@ exports.queryCacheOptionsByPolicy = {
     'cache-and-fetch': Object.assign(Object.assign({}, cacheFirstOptions), { policy: 'cache-and-fetch' }),
 };
 exports.defaultQueryCacheOptions = cacheFirstOptions;
-const defaultRefState = {};
 const useQuery = (cache, options) => {
-    var _a, _b, _c, _d;
-    const getParamsKey = (_a = cache.queries[options.query].getParamsKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetParamsKey);
-    const { query: queryKey, skip, params: hookParams, cacheOptions: cacheOptionsOrPolicy = (_b = cache.queries[queryKey].cacheOptions) !== null && _b !== void 0 ? _b : exports.defaultQueryCacheOptions, mergeResults = cache.queries[queryKey].mergeResults, getCacheKey = (_c = cache.queries[queryKey].getCacheKey) !== null && _c !== void 0 ? _c : getParamsKey, } = options;
-    const hookParamsKey = getParamsKey(
-    // @ts-expect-error fix later
-    hookParams);
+    var _a, _b, _c;
+    const { query: queryKey, skip, params, cacheOptions: cacheOptionsOrPolicy = (_a = cache.queries[queryKey].cacheOptions) !== null && _a !== void 0 ? _a : exports.defaultQueryCacheOptions, getCacheKey = cache.queries[queryKey].getCacheKey, } = options;
+    const logsEnabled = cache.options.logsEnabled;
+    const getParamsKey = (_b = cache.queries[queryKey].getParamsKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetParamsKey);
+    const cacheResultSelector = cache.queries[queryKey].resultSelector;
+    const cacheStateSelector = cache.cacheStateSelector;
     const cacheOptions = typeof cacheOptionsOrPolicy === 'string'
         ? exports.queryCacheOptionsByPolicy[cacheOptionsOrPolicy]
         : cacheOptionsOrPolicy;
@@ -50,131 +40,63 @@ const useQuery = (cache, options) => {
                 ['options.query', options.query],
                 ['queryKey', queryKey],
                 ['resultSelector', cache.queries[queryKey].resultSelector],
+                ['mergeResults', cache.queries[queryKey].mergeResults],
+                ['getParamsKey', cache.queries[queryKey].getParamsKey],
+                ['getCacheKey', cache.queries[queryKey].getCacheKey],
             ]
                 // eslint-disable-next-line react-hooks/rules-of-hooks
                 .forEach((args) => (0, utilsAndConstants_1.useAssertValueNotChanged)(...args));
         })();
-    const forceUpdate = (0, utilsAndConstants_1.useForceUpdate)();
-    // Keeps most of local state.
-    // Reference because state is changed not only by changing hook arguments, but also by calling fetch, and it should be done synchronously.
-    const stateRef = (0, react_1.useRef)(defaultRefState);
-    (0, react_1.useMemo)(() => {
-        if (stateRef.current.paramsKey === hookParamsKey) {
-            return;
-        }
-        const state = stateRef.current;
-        state.resultSelector = createResultSelector(
-        // @ts-expect-error fix later
-        cache.queries[queryKey].resultSelector, cache.cacheStateSelector, hookParams);
-        if (skip) {
-            return;
-        }
-        state.params = hookParams;
-        state.paramsKey = hookParamsKey;
-        state.latestHookParamsKey = state.paramsKey;
-        // @ts-expect-error fix later
-        state.cacheKey = getCacheKey(hookParams);
+    const paramsKey = getParamsKey(
+    // @ts-expect-error fix later
+    params);
+    const [cacheKey, resultSelector] = (0, react_1.useMemo)(() => {
+        const cacheKeyImpl = getCacheKey
+            ? // @ts-expect-error fix types later
+                getCacheKey(params)
+            : paramsKey;
+        const resultSelectorImpl = cacheResultSelector &&
+            ((state) => cacheResultSelector(cacheStateSelector(state), 
+            // @ts-expect-error fix types later
+            params));
+        return [cacheKeyImpl, resultSelectorImpl];
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [hookParamsKey, skip]);
-    const resultFromSelector = 
+    }, [paramsKey]);
     // eslint-disable-next-line react-hooks/rules-of-hooks
-    stateRef.current.resultSelector && (0, react_redux_1.useSelector)(stateRef.current.resultSelector);
+    const resultFromSelector = (resultSelector && (0, react_redux_1.useSelector)(resultSelector));
     const hasResultFromSelector = resultFromSelector !== undefined;
-    const queryStateSelector = (0, react_1.useCallback)((state, cacheKey = stateRef.current.cacheKey) => {
-        cache.options.logsEnabled &&
-            (0, utilsAndConstants_1.log)('queryStateSelector', {
-                state,
-                queryKey,
-                cacheKey,
-                cacheState: cache.cacheStateSelector(state),
-            });
-        const queryState = cache.cacheStateSelector(state).queries[queryKey][cacheKey];
+    const cacheOptionsKey = `${cacheOptions.policy}${cacheOptions.cacheEntities}${cacheOptions.cacheQueryState}`; // Allows to not memoize cache options
+    const fetch = (0, react_1.useCallback)(() => {
+        return (0, query_1.query)('useQuery.fetch', false, store, cache, queryKey, cacheKey, cacheOptions, params);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [cacheKey, paramsKey, cacheOptionsKey]); // TODO put args to ref and make empty deps?
+    const queryStateFromSelector = (_c = (0, react_redux_1.useSelector)((state) => {
+        const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
-    }, 
-    // cacheKey needed only to re-evaluate queryStateSelector later
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [stateRef.current.cacheKey]);
-    const queryStateFromSelector = (_d = (0, react_redux_1.useSelector)(queryStateSelector)) !== null && _d !== void 0 ? _d : utilsAndConstants_1.defaultQueryMutationState;
+    })) !== null && _c !== void 0 ? _c : utilsAndConstants_1.defaultQueryMutationState;
     const queryState = hasResultFromSelector
         ? (Object.assign(Object.assign({}, queryStateFromSelector), { result: resultFromSelector }))
         : queryStateFromSelector;
-    const fetchImpl = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
-        var _e;
-        cache.options.logsEnabled && (0, utilsAndConstants_1.log)('useQuery.fetchImpl', { queryState });
-        if (queryState.loading) {
-            return;
-        }
-        const { params, cacheKey } = stateRef.current;
-        cacheOptions.cacheQueryState &&
-            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
-                loading: true,
-            }));
-        let response;
-        const fetchFn = cache.queries[queryKey].query;
-        try {
-            response = yield fetchFn(
-            // @ts-expect-error fix later
-            params);
-        }
-        catch (error) {
-            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
-                error: error,
-                loading: false,
-            }));
-        }
-        if (response) {
-            const newState = cacheOptions.cacheQueryState
-                ? {
-                    error: undefined,
-                    loading: false,
-                    result: hasResultFromSelector
-                        ? undefined
-                        : mergeResults
-                            ? mergeResults(
-                            // @ts-expect-error fix later
-                            (_e = queryStateSelector(store.getState(), cacheKey)) === null || _e === void 0 ? void 0 : _e.result, response, params)
-                            : response.result,
-                }
-                : undefined;
-            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, newState, cacheOptions.cacheEntities ? response : undefined));
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }), [mergeResults, queryState.loading, hasResultFromSelector]);
     (0, react_1.useEffect)(() => {
         if (skip) {
+            logsEnabled && (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch', { skip, paramsKey });
             return;
         }
         if (queryState.result != null && cacheOptions.policy === 'cache-first') {
+            logsEnabled &&
+                (0, utilsAndConstants_1.log)('useQuery.useEffect don`t fetch due to cache policy', {
+                    result: queryState.result,
+                    policy: cacheOptions.policy,
+                });
             return;
         }
-        fetchImpl();
+        fetch();
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [stateRef.current.latestHookParamsKey]);
-    const fetch = (0, react_1.useCallback)((params) => {
-        cache.options.logsEnabled && (0, utilsAndConstants_1.log)('useQuery.fetch', params);
-        if (params !== undefined) {
-            const state = stateRef.current;
-            // @ts-expect-error fix later
-            const paramsKey = getParamsKey(params);
-            if (state.paramsKey !== paramsKey) {
-                const resultSelectorImpl = cache.queries[queryKey].resultSelector;
-                state.params = params;
-                state.paramsKey = paramsKey;
-                // @ts-expect-error fix later
-                state.cacheKey = getCacheKey(params);
-                state.resultSelector = createResultSelector(
-                // @ts-expect-error fix later
-                resultSelectorImpl, cache.cacheStateSelector, hookParams);
-                forceUpdate();
-            }
-        }
-        return fetchImpl();
-    }, 
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [fetchImpl, getCacheKey]);
-    cache.options.logsEnabled &&
-        console.debug('[useQuery]', {
-            state: stateRef.current,
+    }, [paramsKey, cacheOptions.policy, skip]);
+    logsEnabled &&
+        (0, utilsAndConstants_1.log)('useQuery', {
+            paramsKey,
+            cacheKey,
             options,
             resultFromSelector,
             queryState,
@@ -182,6 +104,3 @@ const useQuery = (cache, options) => {
     return [queryState, fetch];
 };
 exports.useQuery = useQuery;
-const createResultSelector = (resultSelector, cacheStateSelector, params) => {
-    return (resultSelector && ((state) => resultSelector(cacheStateSelector(state), params)));
-};

package/dist/utilsAndConstants.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { CacheOptions, EntitiesMap, EntityChanges, Typenames } from './types';
 export declare const PACKAGE_SHORT_NAME = "RRC";
 export declare const isDev: boolean;
@@ -12,12 +11,8 @@ export declare const defaultQueryMutationState: {
     readonly error: undefined;
 };
 export declare const defaultGetParamsKey: <P = unknown>(params: P) => string;
-/**
- * @returns function to force update a function component.
- */
-export declare const useForceUpdate: () => import("react").DispatchWithoutAction;
 export declare const useAssertValueNotChanged: (name: string, value: unknown) => void;
-export declare const log: (tag: string, data: unknown) => void;
+export declare const log: (tag: string, data?: unknown) => void;
 /**
  * Process changes to entities map.
  * @return `undefined` if nothing to change, otherwise processed entities map.

package/dist/utilsAndConstants.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processEntityChanges = exports.log = exports.useAssertValueNotChanged = exports.useForceUpdate = exports.defaultGetParamsKey = exports.defaultQueryMutationState = exports.defaultCacheOptions = exports.isDev = exports.PACKAGE_SHORT_NAME = void 0;
+exports.processEntityChanges = exports.log = exports.useAssertValueNotChanged = exports.defaultGetParamsKey = exports.defaultQueryMutationState = exports.defaultCacheOptions = exports.isDev = exports.PACKAGE_SHORT_NAME = void 0;
 const react_1 = require("react");
-const react_2 = require("react");
 exports.PACKAGE_SHORT_NAME = 'RRC';
 exports.isDev = (() => {
     try {
@@ -30,14 +29,6 @@ const defaultGetParamsKey = (params) => {
     }
 };
 exports.defaultGetParamsKey = defaultGetParamsKey;
-const forceUpdateReducer = (i) => i + 1;
-/**
- * @returns function to force update a function component.
- */
-const useForceUpdate = () => {
-    return (0, react_2.useReducer)(forceUpdateReducer, 0)[1];
-};
-exports.useForceUpdate = useForceUpdate;
 const useAssertValueNotChanged = (name, value) => {
     const firstMountRef = (0, react_1.useRef)(false);
     (0, react_1.useMemo)(() => {

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "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",
     "build": "yarn clean && tsc && yarn pack -f package.tgz",
-    "test": "node node_modules/jest/bin/jest.js --env=jsdom",
+    "test": "node node_modules/jest/bin/jest.js",
     "prepublishOnly": "yarn build && yarn test"
   },
   "devDependencies": {