react-redux-cache 0.18.4 → 0.19.1

package/dist/createCache.js

@@ -27,7 +27,7 @@ const withTypenames = () => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
             var _o, _p, _q, _r, _s, _t;
             const abortControllers = new WeakMap();
-            // provide all optional fields
+            // Provide all optional fields
             (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
             (_b = (_o = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_o.logsEnabled = false);
             (_c = (_p = partialCache.options).additionalValidation) !== null && _c !== void 0 ? _c : (_p.additionalValidation = utilsAndConstants_1.IS_DEV);
@@ -37,8 +37,8 @@ const withTypenames = () => {
             (_g = (_s = partialCache.globals.queries).fetchPolicy) !== null && _g !== void 0 ? _g : (_s.fetchPolicy = utilsAndConstants_1.FetchPolicy.NoCacheOrExpired);
             (_h = (_t = partialCache.globals.queries).skipFetch) !== null && _h !== void 0 ? _h : (_t.skipFetch = false);
             (_j = partialCache.storeHooks) !== null && _j !== void 0 ? _j : (partialCache.storeHooks = {
-                useStore: require.call(undefined, 'react-redux').useStore,
-                useSelector: require.call(undefined, 'react-redux').useSelector,
+                useStore: require('react-redux').useStore,
+                useSelector: require('react-redux').useSelector,
             });
             (_k = partialCache.cacheStateSelector) !== null && _k !== void 0 ? _k : (partialCache.cacheStateSelector = (state) => state[cache.name]);
             (_l = partialCache.mutations) !== null && _l !== void 0 ? _l : (partialCache.mutations = {});
@@ -46,19 +46,31 @@ const withTypenames = () => {
             // @ts-expect-error private field for testing
             partialCache.abortControllers = abortControllers;
             const cache = partialCache;
-            // validate options
+            // Validate options
             if (cache.options.deepComparisonEnabled && !utilsAndConstants_1.optionalUtils.deepEqual) {
                 console.warn('react-redux-cache: optional dependency for fast-deep-equal was not provided, while deepComparisonEnabled option is true');
             }
-            // selectors
+            // State comparers
+            /** Transforms array of keys to comparer function. */
+            const setDefaultComparer = (target) => {
+                if ((target === null || target === void 0 ? void 0 : target.selectorComparer) != null && typeof target.selectorComparer === 'object') {
+                    target.selectorComparer = (0, utilsAndConstants_1.createStateComparer)(target.selectorComparer);
+                }
+            };
+            setDefaultComparer(cache.globals.queries);
+            for (const queryKey in partialCache.queries) {
+                // @ts-expect-error TODO fix types
+                setDefaultComparer(partialCache.queries[queryKey]);
+            }
+            // Selectors
             const selectors = Object.assign({ selectCacheState: cache.cacheStateSelector }, (0, createSelectors_1.createSelectors)(cache));
             const { selectCacheState, selectQueryState, selectQueryResult, selectQueryLoading, selectQueryError, selectQueryParams, selectQueryExpiresAt, selectMutationState, selectMutationResult, selectMutationLoading, selectMutationError, selectMutationParams, selectEntityById, selectEntities, selectEntitiesByTypename, } = selectors;
-            // actions
+            // Actions
             const actions = (0, createActions_1.createActions)(cache.name);
             const { updateQueryStateAndEntities, updateMutationStateAndEntities, mergeEntityChanges, invalidateQuery, clearQueryState, clearMutationState, clearCache, } = actions;
-            // reducer
+            // Reducer
             const reducer = (0, createCacheReducer_1.createCacheReducer)(actions, Object.keys(cache.queries), cache.options);
-            // createClient
+            // Client creator
             const createClient = (store) => {
                 const client = {
                     query: (options) => {

package/dist/index.d.ts

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

package/dist/index.js

@@ -14,14 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyObject = exports.FetchPolicy = exports.defaultGetCacheKey = exports.useQuerySelectorStateComparer = exports.withTypenames = exports.createCache = void 0;
+exports.isEmptyObject = exports.FetchPolicy = exports.defaultGetCacheKey = exports.createStateComparer = exports.withTypenames = exports.createCache = void 0;
 var createCache_1 = require("./createCache");
 Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return createCache_1.createCache; } });
 Object.defineProperty(exports, "withTypenames", { enumerable: true, get: function () { return createCache_1.withTypenames; } });
 __exportStar(require("./types"), exports);
-var useQuery_1 = require("./useQuery");
-Object.defineProperty(exports, "useQuerySelectorStateComparer", { enumerable: true, get: function () { return useQuery_1.useQuerySelectorStateComparer; } });
 var utilsAndConstants_1 = require("./utilsAndConstants");
+Object.defineProperty(exports, "createStateComparer", { enumerable: true, get: function () { return utilsAndConstants_1.createStateComparer; } });
 Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetCacheKey; } });
 Object.defineProperty(exports, "FetchPolicy", { enumerable: true, get: function () { return utilsAndConstants_1.FetchPolicy; } });
 Object.defineProperty(exports, "isEmptyObject", { enumerable: true, get: function () { return utilsAndConstants_1.isEmptyObject; } });

package/dist/types.d.ts

@@ -45,6 +45,7 @@ export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
         [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<N, T, MP[MK], MR[MK], QP, QR, MP, MR> : never;
     };
 };
+export type QueryStateComparer<T extends Typenames, P, R> = (x: QueryState<T, P, R> | undefined, y: QueryState<T, P, R> | undefined) => boolean;
 export type Globals<N extends string, T extends Typenames, QP, QR, MP, MR> = {
     /** Handles errors, not handled by onError from queries and mutations. @Default undefined. */
     onError?: (error: unknown, key: string, params: unknown, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void;
@@ -58,6 +59,8 @@ export type Globals<N extends string, T extends Typenames, QP, QR, MP, MR> = {
         skipFetch: boolean;
         /** If set, this value updates expiresAt value of query state when query result is received. @Default undefined */
         secondsToLive?: number;
+        /** Either comparer function, or array of keys to subscribe by useQuery's useSelector. @Default compares result, loading, params, error. */
+        selectorComparer?: QueryStateComparer<T, unknown, unknown> | (keyof QueryState<T, unknown, unknown>)[];
     };
 };
 export type CacheOptions = {
@@ -111,6 +114,8 @@ export type QueryInfo<N extends string, T extends Typenames = Typenames, P = unk
     onSuccess?: (response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void;
     /** Called after fetch finished with error. Should return true if error was handled and does not require global onError handling. */
     onError?: (error: unknown, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined;
+    /** Either comparer function, or array of keys to subscribe by useQuery's useSelector. Default compares params, result, loading, error. */
+    selectorComparer?: QueryStateComparer<T, P, R> | (keyof QueryState<T, P, R>)[];
 };
 export type Query<P = unknown, R = unknown> = (
 /** Query parameters */
@@ -129,7 +134,7 @@ export type QueryState<T extends Typenames, P, R> = MutationState<T, P, R> & {
 export type UseQueryOptions<N extends string, T extends Typenames, QK extends keyof (QP & QR), QP, QR, MP, MR> = {
     query: QK;
     params: QK extends keyof (QP | QR) ? QP[QK] : never;
-} & Pick<QueryInfo<N, T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never, QP, QR, MP, MR>, 'fetchPolicy' | 'skipFetch' | 'secondsToLive' | 'mergeResults' | 'onCompleted' | 'onSuccess' | 'onError'>;
+} & Pick<QueryInfo<N, T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never, QP, QR, MP, MR>, 'fetchPolicy' | 'skipFetch' | 'secondsToLive' | 'selectorComparer' | 'mergeResults' | 'onCompleted' | 'onSuccess' | 'onError'>;
 export type QueryOptions<N extends string, T extends Typenames, QP, QR, QK extends keyof (QP & QR), MP, MR> = 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;

package/dist/useQuery.d.ts

@@ -2,5 +2,3 @@ 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: 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<T, 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: <T extends Typenames, P, R>(state1: QueryState<T, P, R> | undefined, state2: QueryState<T, P, R> | undefined) => boolean;

package/dist/useQuery.js

@@ -9,16 +9,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useQuerySelectorStateComparer = exports.useQuery = void 0;
+exports.useQuery = void 0;
 const react_1 = require("react");
 const query_1 = require("./query");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useQuery = (cache, actions, selectors, options) => {
-    var _a, _b, _c;
-    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;
+    var _a, _b, _c, _d, _e;
+    const { query: queryKey, skipFetch = false, params, secondsToLive, selectorComparer, fetchPolicy = (_a = cache.queries[queryKey].fetchPolicy) !== null && _a !== void 0 ? _a : cache.globals.queries.fetchPolicy, mergeResults, onCompleted, onSuccess, onError, } = options;
     const { selectQueryState } = selectors;
+    const queryInfo = cache.queries[queryKey];
     const logsEnabled = cache.options.logsEnabled;
-    const getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
+    const getCacheKey = (_b = queryInfo.getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
+    const comparer = selectorComparer === undefined
+        ? (_d = (_c = queryInfo.selectorComparer) !== null && _c !== void 0 ? _c : cache.globals.queries.selectorComparer) !== null && _d !== void 0 ? _d : defaultStateComparer
+        : typeof selectorComparer === 'function'
+            ? selectorComparer
+            : (0, utilsAndConstants_1.createStateComparer)(selectorComparer);
     const store = cache.storeHooks.useStore();
     // @ts-expect-error fix types later
     const cacheKey = getCacheKey(params);
@@ -35,9 +41,9 @@ const useQuery = (cache, actions, selectors, options) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [store, queryKey, cacheKey]);
     /** Query state */
-    const queryState = (_c = cache.storeHooks.useSelector((state) => {
+    const queryState = (_e = cache.storeHooks.useSelector((state) => {
         return selectQueryState(state, queryKey, cacheKey); // TODO proper type
-    }, (exports.useQuerySelectorStateComparer))) !== null && _c !== void 0 ? _c : utilsAndConstants_1.EMPTY_OBJECT;
+    }, comparer)) !== null && _e !== void 0 ? _e : utilsAndConstants_1.EMPTY_OBJECT;
     (0, react_1.useEffect)(() => {
         if (skipFetch) {
             logsEnabled && (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch', { skipFetch, queryKey, cacheKey });
@@ -68,17 +74,4 @@ const useQuery = (cache, actions, selectors, options) => {
     return [queryState, performFetch];
 };
 exports.useQuery = useQuery;
-/** Omit `expiresAt` from comparison */
-const useQuerySelectorStateComparer = (state1, state2) => {
-    if (state1 === state2) {
-        return true;
-    }
-    if (state1 === undefined || state2 === undefined) {
-        return false;
-    }
-    return (state1.params === state2.params &&
-        state1.loading === state2.loading &&
-        state1.result === state2.result &&
-        state1.error === state2.error);
-};
-exports.useQuerySelectorStateComparer = useQuerySelectorStateComparer;
+const defaultStateComparer = (0, utilsAndConstants_1.createStateComparer)(['result', 'loading', 'params', 'error']);

package/dist/utilsAndConstants.d.ts

@@ -1,4 +1,4 @@
-import type { CacheOptions, EntitiesMap, EntityChanges, Key, QueryState, Typenames } from './types';
+import type { CacheOptions, EntitiesMap, EntityChanges, Key, QueryState, QueryStateComparer, Typenames } from './types';
 export declare const PACKAGE_SHORT_NAME = "rrc";
 export declare const optionalUtils: {
     deepEqual?: (a: any, b: any) => boolean;
@@ -17,3 +17,4 @@ export declare const FetchPolicy: {
 };
 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;
+export declare const createStateComparer: <T extends Typenames = Typenames, Q = unknown, P = unknown>(fields: (keyof QueryState<T, Q, P>)[]) => QueryStateComparer<T, Q, P>;

package/dist/utilsAndConstants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyObject = exports.applyEntityChanges = exports.FetchPolicy = exports.log = exports.defaultGetCacheKey = exports.NOOP = exports.EMPTY_ARRAY = exports.EMPTY_OBJECT = exports.IS_DEV = exports.optionalUtils = exports.PACKAGE_SHORT_NAME = void 0;
+exports.createStateComparer = exports.isEmptyObject = exports.applyEntityChanges = exports.FetchPolicy = exports.log = exports.defaultGetCacheKey = exports.NOOP = 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,
@@ -141,3 +141,21 @@ const isEmptyObject = (o) => {
     return true;
 };
 exports.isEmptyObject = isEmptyObject;
+const createStateComparer = (fields) => {
+    return (x, y) => {
+        if (x === y) {
+            return true;
+        }
+        if (x === undefined || y === undefined) {
+            return false;
+        }
+        for (let i = 0; i < fields.length; i += 1) {
+            const key = fields[i];
+            if (x[key] !== y[key]) {
+                return false;
+            }
+        }
+        return true;
+    };
+};
+exports.createStateComparer = createStateComparer;

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.18.4",
+  "version": "0.19.1",
   "description": "Powerful data fetching and caching library for Redux and Zustand that supports normalization.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",