react-redux-cache 0.19.3 → 0.19.4-rc.0

package/dist/createCacheReducer.js

@@ -1,243 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCacheReducer = void 0;
-const utilsAndConstants_1 = require("./utilsAndConstants");
-const optionalQueryKeys = [
-    'error',
-    'expiresAt',
-    'result',
-    'params',
-    'loading',
-];
-const optionalMutationKeys = [
-    'error',
-    'result',
-    'params',
-    'loading',
-];
-const createCacheReducer = (actions, queryKeys, cacheOptions) => {
-    const initialState = Object.freeze({
-        entities: Object.freeze({}),
-        queries: Object.freeze(queryKeys.reduce((result, x) => {
-            result[x] = Object.freeze({});
-            return result;
-        }, {})),
-        mutations: Object.freeze({}),
-    });
-    cacheOptions.logsEnabled &&
-        (0, utilsAndConstants_1.log)('createCacheReducer', {
-            queryKeys,
-            initialState,
-        });
-    const deepEqual = cacheOptions.deepComparisonEnabled ? utilsAndConstants_1.optionalUtils.deepEqual : undefined;
-    return (state = initialState, action) => {
-        switch (action.type) {
-            case actions.updateQueryStateAndEntities.type: {
-                const { queryKey, queryCacheKey, state: queryState, entityChanges, } = action;
-                const oldQueryState = state.queries[queryKey][queryCacheKey];
-                let newQueryState = queryState && Object.assign(Object.assign({}, oldQueryState), queryState);
-                if (newQueryState) {
-                    if (oldQueryState && deepEqual) {
-                        // set back params if deeply same value
-                        if (newQueryState.params !== oldQueryState.params &&
-                            deepEqual(newQueryState.params, oldQueryState.params)) {
-                            newQueryState.params = oldQueryState.params;
-                        }
-                        // set back if deeply same value
-                        if (newQueryState.result !== oldQueryState.result &&
-                            deepEqual(newQueryState.result, oldQueryState.result)) {
-                            newQueryState.result = oldQueryState.result;
-                        }
-                    }
-                    // remove undefined optional fields
-                    for (const key of optionalQueryKeys) {
-                        if (key in newQueryState && newQueryState[key] === undefined) {
-                            delete newQueryState[key];
-                        }
-                    }
-                    // skip if new state deep equals to the old state
-                    if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldQueryState !== null && oldQueryState !== void 0 ? oldQueryState : utilsAndConstants_1.EMPTY_OBJECT, newQueryState)) {
-                        newQueryState = undefined;
-                    }
-                }
-                const newEntities = entityChanges && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChanges, cacheOptions);
-                let newState;
-                if (newEntities) {
-                    newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
-                    newState.entities = newEntities;
-                }
-                if (newQueryState) {
-                    if (!(0, utilsAndConstants_1.isEmptyObject)(newQueryState)) {
-                        newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
-                        newState.queries = Object.assign(Object.assign({}, state.queries), { [queryKey]: Object.assign(Object.assign({}, state.queries[queryKey]), { [queryCacheKey]: newQueryState }) });
-                    }
-                    else if (oldQueryState !== undefined) {
-                        // empty states are removed
-                        const _a = state.queries[queryKey], _b = queryCacheKey, _ = _a[_b], withoutCacheKey = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-                        newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
-                        newState.queries = Object.assign(Object.assign({}, state.queries), { [queryKey]: withoutCacheKey });
-                    }
-                }
-                return newState !== null && newState !== void 0 ? newState : state;
-            }
-            case actions.updateMutationStateAndEntities.type: {
-                const { mutationKey, state: mutationState, entityChanges, } = action;
-                const oldMutationState = state.mutations[mutationKey];
-                let newMutationState = mutationState && Object.assign(Object.assign({}, oldMutationState), mutationState);
-                if (newMutationState) {
-                    if (oldMutationState && deepEqual) {
-                        // set back params if deeply same value
-                        if (newMutationState.params !== oldMutationState.params &&
-                            deepEqual(newMutationState.params, oldMutationState.params)) {
-                            newMutationState.params = oldMutationState.params;
-                        }
-                        // set back if deeply same value
-                        if (newMutationState.result !== oldMutationState.result &&
-                            deepEqual(newMutationState.result, oldMutationState.result)) {
-                            newMutationState.result = oldMutationState.result;
-                        }
-                    }
-                    // remove optional fields with default values
-                    for (const key of optionalMutationKeys) {
-                        if (key in newMutationState && newMutationState[key] === undefined) {
-                            delete newMutationState[key];
-                        }
-                    }
-                    // skip if new state deep equals to the old state
-                    if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldMutationState !== null && oldMutationState !== void 0 ? oldMutationState : utilsAndConstants_1.EMPTY_OBJECT, newMutationState)) {
-                        newMutationState = undefined;
-                    }
-                }
-                const newEntities = entityChanges && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChanges, cacheOptions);
-                let newState;
-                if (newEntities) {
-                    newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
-                    newState.entities = newEntities;
-                }
-                if (newMutationState) {
-                    if (!(0, utilsAndConstants_1.isEmptyObject)(newMutationState)) {
-                        newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
-                        newState.mutations = Object.assign(Object.assign({}, state.mutations), { [mutationKey]: newMutationState });
-                    }
-                    else if (oldMutationState !== undefined) {
-                        // empty states are removed
-                        const _c = state.mutations, _d = mutationKey, _ = _c[_d], withoutMutationKey = __rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
-                        newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
-                        newState.mutations = withoutMutationKey;
-                    }
-                }
-                return newState !== null && newState !== void 0 ? newState : state;
-            }
-            case actions.mergeEntityChanges.type: {
-                const { changes } = action;
-                const newEntities = (0, utilsAndConstants_1.applyEntityChanges)(state.entities, changes, cacheOptions);
-                return newEntities ? Object.assign(Object.assign({}, state), { entities: newEntities }) : state;
-            }
-            case actions.invalidateQuery.type: {
-                const { queries: queriesToInvalidate } = action;
-                if (queriesToInvalidate.length === 0) {
-                    return state;
-                }
-                const now = Date.now();
-                let newQueries = undefined;
-                for (const { query: queryKey, cacheKey, expiresAt = now } of queriesToInvalidate) {
-                    const queryStates = (newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[queryKey];
-                    if (cacheKey != null) {
-                        if (queryStates[cacheKey]) {
-                            const queryState = queryStates[cacheKey];
-                            if (queryState && queryState.expiresAt !== expiresAt) {
-                                newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                                if (state.queries[queryKey] === newQueries[queryKey]) {
-                                    newQueries[queryKey] = Object.assign({}, newQueries[queryKey]);
-                                }
-                                // @ts-expect-error fix type later
-                                newQueries[queryKey][cacheKey] = Object.assign(Object.assign({}, queryState), { expiresAt });
-                                if (expiresAt === undefined) {
-                                    delete newQueries[queryKey][cacheKey].expiresAt;
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        for (const cacheKey in queryStates) {
-                            const queryState = queryStates[cacheKey];
-                            if (queryState && queryState.expiresAt !== expiresAt) {
-                                newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                                if (state.queries[queryKey] === newQueries[queryKey]) {
-                                    newQueries[queryKey] = Object.assign({}, newQueries[queryKey]);
-                                }
-                                newQueries[queryKey][cacheKey] = Object.assign(Object.assign({}, queryState), { expiresAt });
-                                if (expiresAt === undefined) {
-                                    delete newQueries[queryKey][cacheKey].expiresAt;
-                                }
-                            }
-                        }
-                    }
-                }
-                return newQueries === undefined
-                    ? state
-                    : Object.assign(Object.assign({}, state), { queries: newQueries });
-            }
-            case actions.clearQueryState.type: {
-                const { queries: queriesToClear } = action;
-                if (queriesToClear.length === 0) {
-                    return state;
-                }
-                let newQueries = undefined;
-                for (const { query: queryKey, cacheKey } of queriesToClear) {
-                    const queryStates = (newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[queryKey];
-                    if (cacheKey != null) {
-                        if (queryStates[cacheKey]) {
-                            newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                            if (state.queries[queryKey] === newQueries[queryKey]) {
-                                newQueries[queryKey] = Object.assign({}, newQueries[queryKey]);
-                            }
-                            delete newQueries[queryKey][cacheKey];
-                        }
-                    }
-                    else if (queryStates !== utilsAndConstants_1.EMPTY_OBJECT) {
-                        newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                        newQueries[queryKey] = utilsAndConstants_1.EMPTY_OBJECT;
-                    }
-                }
-                return newQueries === undefined
-                    ? state
-                    : Object.assign(Object.assign({}, state), { queries: newQueries });
-            }
-            case actions.clearMutationState.type: {
-                const { mutationKeys } = action;
-                if (mutationKeys.length === 0) {
-                    return state;
-                }
-                let newMutations = undefined;
-                for (const mutation of mutationKeys) {
-                    if (state.mutations[mutation]) {
-                        newMutations !== null && newMutations !== void 0 ? newMutations : (newMutations = Object.assign({}, state.mutations));
-                        delete newMutations[mutation];
-                    }
-                }
-                return newMutations === undefined
-                    ? state
-                    : Object.assign(Object.assign({}, state), { mutations: newMutations });
-            }
-            case actions.clearCache.type: {
-                const { stateToKeep } = action;
-                return stateToKeep
-                    ? Object.assign(Object.assign({}, initialState), stateToKeep) : initialState;
-            }
-        }
-        return state;
-    };
-};
-exports.createCacheReducer = createCacheReducer;

package/dist/createSelectors.d.ts

@@ -1,18 +0,0 @@
-import { Cache, Key, MutationState, QueryState, Typenames } from './types';
-export type Selectors<N extends string = string, T extends Typenames = Typenames, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = ReturnType<typeof createSelectors<N, T, QP, QR, MP, MR>>;
-export declare const createSelectors: <N extends string, T extends Typenames, QP, QR, MP, MR>(cache: Cache<N, T, QP, QR, MP, MR>) => {
-    selectQueryState: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => QueryState<T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never>;
-    selectQueryResult: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => (QK extends keyof QP & keyof QR ? QR[QK] : never) | undefined;
-    selectQueryLoading: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => false | Promise<import("./types").NormalizedQueryResponse<T, QK extends keyof QP & keyof QR ? QR[QK] : never>>;
-    selectQueryError: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => Error | undefined;
-    selectQueryParams: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => (QK extends keyof QP & keyof QR ? QP[QK] : never) | undefined;
-    selectQueryExpiresAt: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => number | undefined;
-    selectMutationState: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => MutationState<T, MK extends keyof (MP | MR) ? MP[MK] : never, MK extends keyof (MP | MR) ? MR[MK] : never>;
-    selectMutationResult: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => (MK extends keyof MP & keyof MR ? MR[MK] : never) | undefined;
-    selectMutationLoading: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => false | Promise<import("./types").NormalizedQueryResponse<T, MK extends keyof MP & keyof MR ? MR[MK] : never>>;
-    selectMutationError: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => Error | undefined;
-    selectMutationParams: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => (MK extends keyof MP & keyof MR ? MP[MK] : never) | undefined;
-    selectEntityById: <TN extends keyof T>(state: unknown, id: Key | null | undefined, typename: TN) => T[TN] | undefined;
-    selectEntities: (state: unknown) => import("./types").EntitiesMap<T>;
-    selectEntitiesByTypename: <TN extends keyof T>(state: unknown, typename: TN) => import("./types").EntitiesMap<T>[TN];
-};

package/dist/createSelectors.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSelectors = void 0;
-const utilsAndConstants_1 = require("./utilsAndConstants");
-const createSelectors = (cache) => {
-    const selectEntityById = (state, id, typename) => {
-        var _a;
-        return id == null ? undefined : (_a = cache.cacheStateSelector(state).entities[typename]) === null || _a === void 0 ? void 0 : _a[id];
-    };
-    const selectQueryState = (state, query, cacheKey) => {
-        var _a;
-        // @ts-expect-error fix later
-        return (_a = cache.cacheStateSelector(state).queries[query][cacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
-    };
-    const selectMutationState = (state, mutation) => {
-        var _a;
-        // @ts-expect-error fix later
-        return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
-    };
-    return {
-        selectQueryState,
-        selectQueryResult: (state, query, cacheKey) => {
-            return selectQueryState(state, query, cacheKey).result;
-        },
-        selectQueryLoading: (state, query, cacheKey) => {
-            var _a;
-            return (_a = selectQueryState(state, query, cacheKey).loading) !== null && _a !== void 0 ? _a : false;
-        },
-        selectQueryError: (state, query, cacheKey) => {
-            return selectQueryState(state, query, cacheKey).error;
-        },
-        selectQueryParams: (state, query, cacheKey) => {
-            return selectQueryState(state, query, cacheKey).params;
-        },
-        selectQueryExpiresAt: (state, query, cacheKey) => {
-            return selectQueryState(state, query, cacheKey).expiresAt;
-        },
-        selectMutationState,
-        selectMutationResult: (state, mutation) => {
-            return selectMutationState(state, mutation).result;
-        },
-        selectMutationLoading: (state, mutation) => {
-            var _a;
-            return (_a = selectMutationState(state, mutation).loading) !== null && _a !== void 0 ? _a : false;
-        },
-        selectMutationError: (state, mutation) => {
-            return selectMutationState(state, mutation).error;
-        },
-        selectMutationParams: (state, mutation) => {
-            return selectMutationState(state, mutation).params;
-        },
-        selectEntityById,
-        selectEntities: (state) => {
-            return cache.cacheStateSelector(state).entities;
-        },
-        selectEntitiesByTypename: (state, typename) => {
-            return cache.cacheStateSelector(state).entities[typename];
-        },
-    };
-};
-exports.createSelectors = createSelectors;

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,53 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-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.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 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; } });
-// Backlog
-// ! high (1.0.0-rc.0)
-// generate full api docs
-// optimistic response
-// features list (table)
-// ! medium
-// onCancel & onAbort
-// remove empty entities and queries from state
-// globals for success, completions and loading states?
-// make query key / cache key difference more clear in the docs
-// check type of function arguments in dev
-// make skipFetch a function?
-// example -> playground with changable options
-// ! low
-// make error type generic
-// allow multiple mutation with same keys?
-// easy access to all currently loading queries and mutations?
-// cancellation to queries
-// if mutation & query already loading - make options: last, throttle, debounce, parallel?
-// add refresh interval for queries that are mounted?
-// readonly types?
-// proper types, remove as, any, todo
-// add number of retries param?
-// mutation state wrong type - can be undefined?
-// ! on hold
-// better support queries without params: useQuery & selectors optional cache key (making useQuery params optional doesn't seem like a good idea)
-// cancel all queries / mutations (already possible by recreating the store - this lib is pure)

package/dist/mutate.d.ts

@@ -1,4 +0,0 @@
-import type { Actions } from './createActions';
-import { Selectors } from './createSelectors';
-import type { Cache, Key, MutationResult, Store, Typenames } from './types';
-export declare const mutate: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, mutationKey: MK, params: MK extends keyof (MP | MR) ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]>, params: MP[keyof MP & keyof MR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]>, params: MP[keyof MP & keyof MR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]>, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onError?: ((error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | undefined) => Promise<MutationResult<MK extends keyof (MP | MR) ? MR[MK] : never>>;

package/dist/mutate.js

@@ -1,98 +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.mutate = void 0;
-const utilsAndConstants_1 = require("./utilsAndConstants");
-const mutate = (logTag_1, store_1, cache_1, actions_1, selectors_1, mutationKey_1, params_1, abortControllers_1, ...args_1) => __awaiter(void 0, [logTag_1, store_1, cache_1, actions_1, selectors_1, mutationKey_1, params_1, abortControllers_1, ...args_1], void 0, function* (logTag, store, cache, actions, selectors, mutationKey, params, abortControllers, onCompleted = cache.mutations[mutationKey].onCompleted, onSuccess = cache.mutations[mutationKey].onSuccess, onError = cache.mutations[mutationKey].onError) {
-    var _a, _b;
-    const { updateMutationStateAndEntities } = actions;
-    let abortControllersOfStore = abortControllers.get(store);
-    if (abortControllersOfStore === undefined) {
-        abortControllersOfStore = {};
-        abortControllers.set(store, abortControllersOfStore);
-    }
-    {
-        const abortController = abortControllersOfStore[mutationKey];
-        cache.options.logsEnabled &&
-            (0, utilsAndConstants_1.log)(logTag, {
-                mutationKey,
-                params,
-                previousAborted: abortController !== undefined,
-            });
-        if (abortController !== undefined) {
-            abortController.abort();
-        }
-    }
-    const abortController = new AbortController();
-    abortControllersOfStore[mutationKey] = abortController;
-    const mutatePromise = cache.mutations[mutationKey].mutation(
-    // @ts-expect-error fix later
-    params, store, abortController.signal);
-    store.dispatch(updateMutationStateAndEntities(mutationKey, {
-        // @ts-expect-error TODO fix types
-        loading: mutatePromise,
-        params,
-        result: undefined,
-    }));
-    let response;
-    let error;
-    try {
-        response = yield mutatePromise;
-    }
-    catch (e) {
-        error = e;
-    }
-    cache.options.logsEnabled &&
-        (0, utilsAndConstants_1.log)(`${logTag} finished`, {
-            response,
-            error,
-            aborted: abortController.signal.aborted,
-        });
-    if (abortController.signal.aborted) {
-        return ABORTED_RESULT;
-    }
-    delete abortControllersOfStore[mutationKey];
-    if (error) {
-        store.dispatch(updateMutationStateAndEntities(mutationKey, {
-            error: error,
-            loading: undefined,
-        }));
-        // @ts-expect-error params
-        if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store, actions, selectors))) {
-            (_b = (_a = cache.globals).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error, 
-            // @ts-expect-error mutationKey
-            mutationKey, params, store, actions, selectors);
-        }
-        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(
-        // @ts-expect-error response
-        response, error, params, store, actions, selectors);
-        return { error };
-    }
-    if (response) {
-        const newState = {
-            error: undefined,
-            loading: undefined,
-            result: response.result,
-        };
-        store.dispatch(updateMutationStateAndEntities(mutationKey, newState, response));
-        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(
-        // @ts-expect-error response
-        response, params, store, actions, selectors);
-        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(
-        // @ts-expect-error response
-        response, error, params, store, actions, selectors);
-        // @ts-expect-error fix later
-        return { result: response.result };
-    }
-    throw new Error(`${logTag}: both error and response are not defined`);
-});
-exports.mutate = mutate;
-const ABORTED_RESULT = Object.freeze({ aborted: true });

package/dist/query.d.ts

@@ -1,4 +0,0 @@
-import type { Actions } from './createActions';
-import { Selectors } from './createSelectors';
-import type { Cache, Key, QueryResult, Store, Typenames } from './types';
-export declare const query: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof (QP & QR)>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, queryKey: QK, cacheKey: Key, params: QK extends keyof (QP | QR) ? QP[QK] : never, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => QR[keyof QP & keyof QR & symbol]) | undefined, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onError?: ((error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | undefined) => Promise<QueryResult<QK extends keyof (QP | QR) ? QR[QK] : never>>;

package/dist/query.js

@@ -1,107 +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.query = void 0;
-const utilsAndConstants_1 = require("./utilsAndConstants");
-const query = (logTag, store, cache, actions, selectors, queryKey, cacheKey, params, secondsToLive, onlyIfExpired, mergeResults, onCompleted, onSuccess, onError) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d;
-    if (secondsToLive === void 0) { secondsToLive = (_a = cache.queries[queryKey].secondsToLive) !== null && _a !== void 0 ? _a : cache.globals.queries.secondsToLive; }
-    if (mergeResults === void 0) { mergeResults = cache.queries[queryKey].mergeResults; }
-    if (onCompleted === void 0) { onCompleted = cache.queries[queryKey].onCompleted; }
-    if (onSuccess === void 0) { onSuccess = cache.queries[queryKey].onSuccess; }
-    if (onError === void 0) { onError = cache.queries[queryKey].onError; }
-    const { selectQueryResult, selectQueryState } = selectors;
-    const logsEnabled = cache.options.logsEnabled;
-    const queryStateOnStart = selectQueryState(store.getState(), queryKey, cacheKey);
-    if (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.loading) {
-        logsEnabled &&
-            (0, utilsAndConstants_1.log)(`${logTag} fetch cancelled: already loading`, {
-                queryStateOnStart,
-                params,
-                cacheKey,
-            });
-        const error = yield queryStateOnStart.loading.then(utilsAndConstants_1.NOOP).catch(catchAndReturn);
-        return error
-            ? {
-                cancelled: 'loading',
-                error,
-            }
-            : {
-                cancelled: 'loading',
-                result: selectQueryResult(store.getState(), queryKey, cacheKey),
-            };
-    }
-    if (onlyIfExpired && (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.expiresAt) != null && queryStateOnStart.expiresAt > Date.now()) {
-        logsEnabled &&
-            (0, utilsAndConstants_1.log)(`${logTag} fetch cancelled: not expired yet`, {
-                queryStateOnStart,
-                params,
-                cacheKey,
-                onlyIfExpired,
-            });
-        return {
-            cancelled: 'not-expired',
-            result: queryStateOnStart.result,
-        };
-    }
-    const { updateQueryStateAndEntities } = actions;
-    const fetchPromise = cache.queries[queryKey].query(
-    // @ts-expect-error fix later
-    params, store);
-    store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
-        loading: fetchPromise,
-        params,
-    }));
-    logsEnabled && (0, utilsAndConstants_1.log)(`${logTag} started`, { queryKey, params, cacheKey, queryStateOnStart, onlyIfExpired });
-    let response;
-    try {
-        response = yield fetchPromise;
-    }
-    catch (error) {
-        store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
-            error: error,
-            loading: undefined,
-        }));
-        // @ts-expect-error params
-        if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store))) {
-            (_c = (_b = cache.globals).onError) === null || _c === void 0 ? void 0 : _c.call(_b, error, 
-            // @ts-expect-error queryKey
-            queryKey, params, store, actions, selectors);
-        }
-        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(undefined, error, 
-        // @ts-expect-error params
-        params, store, actions, selectors);
-        return { error };
-    }
-    const newState = {
-        error: undefined,
-        loading: undefined,
-        expiresAt: (_d = response.expiresAt) !== null && _d !== void 0 ? _d : (secondsToLive != null ? Date.now() + secondsToLive * 1000 : undefined),
-        result: mergeResults
-            ? mergeResults(
-            // @ts-expect-error fix later
-            selectQueryResult(store.getState(), queryKey, cacheKey), response, params, store, actions, selectors)
-            : response.result,
-    };
-    store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));
-    onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(
-    // @ts-expect-error response
-    response, params, store, actions, selectors);
-    onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(
-    // @ts-expect-error response
-    response, undefined, params, store, actions, selectors);
-    return {
-        // @ts-expect-error fix types
-        result: newState === null || newState === void 0 ? void 0 : newState.result,
-    };
-});
-exports.query = query;
-const catchAndReturn = (x) => x;