react-redux-cache 0.19.3 → 0.19.4

package/dist/types.d.ts

@@ -1,187 +0,0 @@
-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. */
-    merge?: PartialEntitiesMap<T>;
-    /** Entities that will replace existing. */
-    replace?: Partial<EntitiesMap<T>>;
-    /** Ids of entities that will be removed. */
-    remove?: EntityIds<T>;
-    /** 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;
-    /** Cache options. */
-    options: CacheOptions;
-    /** Default options for queries and mutations. */
-    globals: Globals<N, T, QP, QR, MP, MR>;
-    /** Hooks to access and subscribe to the store. Imported from react-redux if not overridden. */
-    storeHooks: {
-        useStore: () => Store;
-        useSelector: <R>(selector: (state: unknown) => R, comparer?: (x: R, y: R) => boolean) => R;
-    };
-    /** Should return cache state from store root state. Default implementation returns `state[name]`. */
-    cacheStateSelector: (state: any) => CacheState<T, QP, QR, MP, MR>;
-    /** Queries. */
-    queries: {
-        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<N, T, QP[QK], QR[QK], QP, QR, MP, MR> : never;
-    };
-    /** Mutations. */
-    mutations: {
-        [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;
-    /** 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<T, 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;
-        /** 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 = {
-    /** 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 */
-    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
-     */
-    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: {
-        [QK in keyof (QP | QR)]: Dict<QueryState<T, QP[QK], QR[QK]> | undefined>;
-    };
-    mutations: {
-        [MK in keyof (MP | MR)]: MutationState<T, MP[MK], MR[MK]>;
-    };
-};
-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<T, 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, 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 `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 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, 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 */
-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.
-     * Hooks may refetch the query again when component mounts, cache key or skip option change, depending on the fetch policy.
-     * Client query calls also start making fetch if onlyIfExpired argument is truthy.
-     * */
-    expiresAt?: number;
-};
-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' | '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;
-};
-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, 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> = (
-/** Mutation parameters */
-params: P, 
-/** Store */
-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<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;
-};
-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>>;
-    /** Result of the latest successfull response. */
-    result?: R;
-    /** Error of the latest response. */
-    error?: Error;
-    /** Parameters of the latest request. */
-    params?: P;
-};

package/dist/types.js

@@ -1,3 +0,0 @@
-"use strict";
-// Common
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/useMutation.d.ts

@@ -1,4 +0,0 @@
-import { Actions } from './createActions';
-import { Selectors } from './createSelectors';
-import { Cache, Key, MutateOptions, MutationState, Store, Typenames } from './types';
-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<T, MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];

package/dist/useMutation.js

@@ -1,61 +0,0 @@
-"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.useMutation = void 0;
-const react_1 = require("react");
-const mutate_1 = require("./mutate");
-const utilsAndConstants_1 = require("./utilsAndConstants");
-const useMutation = (cache, actions, selectors, options, abortControllers) => {
-    var _a;
-    const { mutation: mutationKey, onCompleted, onSuccess, onError } = options;
-    const store = cache.storeHooks.useStore();
-    // Using single useMemo for performance reasons
-    const [mutationStateSelector, mutate, abort] = (0, react_1.useMemo)(() => {
-        return [
-            // mutationStateSelector
-            (state) => {
-                cache.options.logsEnabled &&
-                    (0, utilsAndConstants_1.log)('mutationStateSelector', {
-                        state,
-                        cacheState: cache.cacheStateSelector(state),
-                    });
-                return cache.cacheStateSelector(state).mutations[mutationKey];
-            },
-            // mutate
-            (params) => __awaiter(void 0, void 0, void 0, function* () {
-                return yield (0, mutate_1.mutate)('useMutation.mutate', store, cache, actions, selectors, mutationKey, params, abortControllers, 
-                // @ts-expect-error fix later
-                onCompleted, onSuccess, onError);
-            }),
-            // abort
-            () => {
-                var _a;
-                const abortController = (_a = abortControllers.get(store)) === null || _a === void 0 ? void 0 : _a[mutationKey];
-                if (abortController === undefined || abortController.signal.aborted) {
-                    return false;
-                }
-                abortController.abort();
-                store.dispatch(actions.updateMutationStateAndEntities(mutationKey, { loading: undefined }));
-                return true;
-            },
-        ];
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [mutationKey, store]);
-    // @ts-expect-error fix later
-    const mutationState = (_a = cache.storeHooks.useSelector(mutationStateSelector)) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
-    cache.options.logsEnabled &&
-        (0, utilsAndConstants_1.log)('useMutation', {
-            options,
-            mutationState,
-        });
-    return [mutate, mutationState, abort];
-};
-exports.useMutation = useMutation;

package/dist/useQuery.d.ts

@@ -1,4 +0,0 @@
-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>>];

package/dist/useQuery.js

@@ -1,77 +0,0 @@
-"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 = 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, _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 = 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);
-    /** Fetch query with the new parameters, or refetch with the same if parameters not provided. */
-    const performFetch = (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, 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, 
-        // @ts-expect-error fix later
-        mergeResults, onCompleted, onSuccess, onError);
-    }), 
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [store, queryKey, cacheKey]);
-    /** Query state */
-    const queryState = (_e = cache.storeHooks.useSelector((state) => {
-        return selectQueryState(state, queryKey, cacheKey); // TODO proper type
-    }, 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 });
-            return;
-        }
-        const expired = queryState.expiresAt != null && queryState.expiresAt <= Date.now();
-        if (!fetchPolicy(expired, 
-        // @ts-expect-error params
-        params, queryState, store, selectors)) {
-            logsEnabled &&
-                (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch due to fetch policy', {
-                    queryState,
-                    expired,
-                    queryKey,
-                    cacheKey,
-                });
-            return;
-        }
-        performFetch();
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [cacheKey, skipFetch]);
-    logsEnabled &&
-        (0, utilsAndConstants_1.log)('useQuery', {
-            cacheKey,
-            options,
-            queryState,
-        });
-    return [queryState, performFetch];
-};
-exports.useQuery = useQuery;
-const defaultStateComparer = (0, utilsAndConstants_1.createStateComparer)(['result', 'loading', 'params', 'error']);

package/dist/utilsAndConstants.d.ts

@@ -1,20 +0,0 @@
-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;
-};
-export declare const IS_DEV: boolean;
-export declare const EMPTY_OBJECT: Readonly<{}>;
-export declare const EMPTY_ARRAY: readonly never[];
-export declare const NOOP: () => void;
-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;
-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,161 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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,
-};
-try {
-    exports.optionalUtils.deepEqual = require('fast-deep-equal/es6');
-}
-catch (_a) {
-    console.debug(exports.PACKAGE_SHORT_NAME + ': fast-deep-equal optional dependency was not installed');
-}
-exports.IS_DEV = (() => {
-    try {
-        // @ts-expect-error __DEV__ is only for React Native
-        return __DEV__;
-    }
-    catch (e) {
-        return process.env.NODE_ENV === 'development';
-    }
-})();
-exports.EMPTY_OBJECT = Object.freeze({});
-exports.EMPTY_ARRAY = Object.freeze([]);
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const NOOP = () => { };
-exports.NOOP = NOOP;
-const defaultGetCacheKey = (params) => {
-    switch (typeof params) {
-        case 'string':
-        case 'symbol':
-            return params;
-        case 'object':
-            return JSON.stringify(params);
-        default:
-            return String(params);
-    }
-};
-exports.defaultGetCacheKey = defaultGetCacheKey;
-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, _params, 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) {
-        console.warn('react-redux-cache.applyEntityChanges: merge and entities should not be both set');
-    }
-    const { merge = changes.entities, replace, remove } = changes;
-    if (!merge && !replace && !remove) {
-        return undefined;
-    }
-    const deepEqual = options.deepComparisonEnabled ? exports.optionalUtils.deepEqual : undefined;
-    let result;
-    // TODO refactor to remove this Set
-    const typenames = new Set([
-        ...(changes.entities ? Object.keys(changes.entities) : exports.EMPTY_ARRAY),
-        ...(changes.merge ? Object.keys(changes.merge) : exports.EMPTY_ARRAY),
-        ...(changes.remove ? Object.keys(changes.remove) : exports.EMPTY_ARRAY),
-        ...(changes.replace ? Object.keys(changes.replace) : exports.EMPTY_ARRAY),
-    ]);
-    for (const typename of typenames) {
-        const entitiesToMerge = merge === null || merge === void 0 ? void 0 : merge[typename];
-        const entitiesToReplace = replace === null || replace === void 0 ? void 0 : replace[typename];
-        const entitiesToRemove = remove === null || remove === void 0 ? void 0 : remove[typename];
-        if (!entitiesToMerge && !entitiesToReplace && !(entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.length)) {
-            continue;
-        }
-        // check for key intersection
-        if (options.additionalValidation) {
-            const mergeIds = entitiesToMerge && Object.keys(entitiesToMerge);
-            const replaceIds = entitiesToReplace && Object.keys(entitiesToReplace);
-            const idsSet = new Set(mergeIds);
-            replaceIds === null || replaceIds === void 0 ? void 0 : replaceIds.forEach((id) => idsSet.add(id));
-            entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.forEach((id) => idsSet.add(String(id))); // String() because Object.keys always returns strings
-            const totalKeysInResponse = ((_a = mergeIds === null || mergeIds === void 0 ? void 0 : mergeIds.length) !== null && _a !== void 0 ? _a : 0) + ((_b = replaceIds === null || replaceIds === void 0 ? void 0 : replaceIds.length) !== null && _b !== void 0 ? _b : 0) + ((_c = entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.length) !== null && _c !== void 0 ? _c : 0);
-            if (totalKeysInResponse !== 0 && idsSet.size !== totalKeysInResponse) {
-                console.warn('react-redux-cache.applyEntityChanges: merge, replace and remove changes have intersections for: ' +
-                    typename);
-            }
-        }
-        const oldEntities = (_d = entities[typename]) !== null && _d !== void 0 ? _d : exports.EMPTY_OBJECT;
-        let newEntities;
-        // remove
-        entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.forEach((id) => {
-            if (oldEntities[id]) {
-                newEntities !== null && newEntities !== void 0 ? newEntities : (newEntities = Object.assign({}, oldEntities));
-                delete newEntities[id];
-            }
-        });
-        // replace
-        if (entitiesToReplace) {
-            for (const id in entitiesToReplace) {
-                const newEntity = entitiesToReplace[id];
-                if (!(deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldEntities[id], newEntity))) {
-                    newEntities !== null && newEntities !== void 0 ? newEntities : (newEntities = Object.assign({}, oldEntities));
-                    newEntities[id] = newEntity;
-                }
-            }
-        }
-        // merge
-        if (entitiesToMerge) {
-            for (const id in entitiesToMerge) {
-                const oldEntity = oldEntities[id];
-                const newEntity = Object.assign(Object.assign({}, oldEntity), entitiesToMerge[id]);
-                if (!(deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldEntity, newEntity))) {
-                    newEntities !== null && newEntities !== void 0 ? newEntities : (newEntities = Object.assign({}, oldEntities));
-                    newEntities[id] = newEntity;
-                }
-            }
-        }
-        if (!newEntities) {
-            continue;
-        }
-        result !== null && result !== void 0 ? result : (result = Object.assign({}, entities));
-        // @ts-expect-error fix later
-        result[typename] = newEntities;
-    }
-    options.logsEnabled &&
-        (0, exports.log)('applyEntityChanges', {
-            entities,
-            changes,
-            options,
-            result,
-        });
-    return result;
-};
-exports.applyEntityChanges = applyEntityChanges;
-const isEmptyObject = (o) => {
-    for (const _ in o) {
-        return false;
-    }
-    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;