@ngrx-traits/core 12.1.1 → 13.0.0-beta.1

package/cache/cache.service.d.ts

@@ -56,10 +56,11 @@ import { CacheKey } from './cache.models';
  * @param options.expires - time to expire the cache valued, if not present is infinite
  * @param options.maxCacheSize - max number of keys to store , only works if last key is variable
  */
-export declare function cache<T>({ store, key, source, expires, maxCacheSize, }: {
+export declare function cache<T>({ store, key, source, expires, maxCacheSize, skip, }: {
     store: Store;
     key: CacheKey;
     source: Observable<T>;
     expires?: number;
     maxCacheSize?: number;
+    skip?: boolean;
 }): Observable<any>;

package/create-entity-feature.d.ts

@@ -1,27 +1,101 @@
 import { Config, ExtractActionsType, ExtractSelectorsType, ExtractStateType, EntityFeatureFactory, FeatureSelectors, KeyedConfig, TraitActions, TraitFactory, TraitSelectors, TraitStateMutators, UnionToIntersection, TraitActionsFactory, TraitSelectorsFactory, TraitInitialStateFactory, TraitStateMutatorsFactory, TraitReducerFactory, TraitEffectsFactory } from './model';
 import { ActionType } from '@ngrx/store';
 import { Type } from './local-store';
-export declare function createTraitFactory<State = {}, A extends TraitActions = {}, S extends TraitSelectors<State> = {}, M extends TraitStateMutators<State> = {}, KEY extends string = string, C = unknown, KC = KeyedConfig<KEY, C>>(f: {
-    key: KEY;
-    config?: C;
-    depends?: string[];
-    actions?: TraitActionsFactory<A, KC>;
-    selectors?: TraitSelectorsFactory<State, S, KC>;
-    initialState?: TraitInitialStateFactory<State, KC>;
-    mutators?: TraitStateMutatorsFactory<State, M, KC>;
-    reducer?: TraitReducerFactory<State, A, S, M, KC>;
-    effects?: TraitEffectsFactory<State, A, S, KC>;
-}): TraitFactory<State, A, S, M, KEY, C, KC>;
-export declare function createEntityFeatureFactory<F extends readonly TraitFactory[]>(...traits: F): EntityFeatureFactory<'Entity', 'Entities', ExtractStateType<F>, ExtractActionsType<F>, ExtractSelectorsType<F>>;
+/**
+ * Creates a function that when execute will combine all the traits, and return a EntityFeatureFactory
+ * which combines all the traits actions, selectors , reducers and effects,
+ * the names param will replace any action and selector with the word Entity or Entities,
+ * with the corresponding entityName and  entitiesName param (entityName+'s' if entitiesName is omitted).
+ * @param namesConfig - Optional Names for entities
+ * @param namesConfig.entityName - singular name for entity
+ * @param [namesConfig.entitiesName] - plural name for entities, defaults to entityName + 's'
+ * @param traits set of traits to be combined
+ *
+ * @example
+ *
+ * const featureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntityTrait<Product>(),
+ *   addAsyncActionTrait({
+ *     name: 'checkout',
+ *     actionSuccessProps: props<{ orderId: string }>(),
+ *   })
+ * );
+ *
+ * export const productsFeature = featureFactory({
+ *   actionsGroupKey: '[Products]',
+ *   featureSelector: 'products',
+ * });
+ */
 export declare function createEntityFeatureFactory<F extends readonly TraitFactory[], EntityName extends string, EntitiesName extends string = `${EntityName}s`>({ entityName, entitiesName, }: {
     entityName: EntityName;
     entitiesName?: EntitiesName;
 }, ...traits: F): EntityFeatureFactory<EntityName, EntitiesName, ExtractStateType<F>, ExtractActionsType<F>, ExtractSelectorsType<F>>;
-export declare function setPropertyReducer<State, P extends keyof State>(sourceReducer: (state: State, action: ActionType<any>) => State, property: P, propertyReducer: (state: State[P], action: ActionType<any>) => State[P]): (state: State, action: ActionType<any>) => State;
-export declare function setPropertiesReducer<State, P extends keyof State>(sourceReducer: (state: State, action: ActionType<any>) => State, propertiesReducers: {
-    [key in P]: (state: State[P], action: ActionType<any>) => State[P];
-}): (state: State, action: ActionType<any>) => State;
-export declare function joinReducers<State>(firstReducer: (state: State, action: ActionType<any>) => State, secondReducer: (state: any, action: ActionType<any>) => any): (state: State, action: ActionType<any>) => State;
+/**
+ * Creates a function that when execute will combine all the traits, and return a EntityFeatureFactory
+ * which combines all the traits actions, selectors , reducers and effects.
+ * @param traits set of traits to be combined
+ *
+ * @example
+ *
+ * const featureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntityTrait<Product>(),
+ *   addAsyncActionTrait({
+ *     name: 'checkout',
+ *     actionSuccessProps: props<{ orderId: string }>(),
+ *   })
+ * );
+ *
+ * export const productsFeature = featureFactory({
+ *   actionsGroupKey: '[Products]',
+ *   featureSelector: 'products',
+ * });
+ *
+ * productsFeature.actions.loadProducts();
+ */
+export declare function createEntityFeatureFactory<F extends readonly TraitFactory[]>(...traits: F): EntityFeatureFactory<'Entity', 'Entities', ExtractStateType<F>, ExtractActionsType<F>, ExtractSelectorsType<F>>;
+/**
+ * Combine a map entityFeatureFactories into one,
+ * grouping the actions and selectors by the key of the respective entityFeatureFactory
+ * @param traitFactoriesMap
+ *
+ * @example
+ *
+ * const clientsFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'client', entitiesName: 'clients' },
+ *   addLoadEntitiesTrait<Client>(),
+ *   addCrudEntitiesTrait<Client>()
+ * );
+ *
+ * const productOrderFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'productOrder' },
+ *   addLoadEntitiesTrait<ProductOrder>(),
+ *   addSelectEntitiesTrait<ProductOrder>()
+ * );
+ *
+ * const productFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntitiesTrait<Product>()
+ * );
+ *
+ * const productCombinedFactory = combineEntityFeatures({
+ *   products: productFeatureFactory,
+ *   productOrders: productOrderFeatureFactory,
+ *   clients: clientsFeatureFactory,
+ * });
+ *
+ * const combinedFeature = productCombinedFactory({
+ *     actionsGroupKey: '[Combined]',
+ *     featureSelector: 'combined',
+ *   });
+ *
+ *   combinedFeature.actions.client.loadClients();
+ *   combinedFeature.actions.product.loadProducts();
+ */
 export declare function combineEntityFeatures<T extends {
     [key: string]: EntityFeatureFactory<any, any>;
 }, K extends keyof T, State extends {
@@ -37,11 +111,93 @@ export declare function combineEntityFeatures<T extends {
     effects: Type<any>[];
     initialState: State;
 }>(traitFactoriesMap: T): R;
+/**
+ * Mix a map entityFeatureFactories into one, different from combine the actions and selectors a mix, not group by key like in combine, the keys are still use
+ * internal in the reducers and selector to separate the state
+ * @param traitFactoriesMap
+ *
+ * @example
+ *
+ * const clientsFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'client', entitiesName: 'clients' },
+ *   addLoadEntitiesTrait<Client>(),
+ *   addCrudEntitiesTrait<Client>()
+ * );
+ *
+ * const productOrderFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'productOrder' },
+ *   addLoadEntitiesTrait<ProductOrder>(),
+ *   addSelectEntitiesTrait<ProductOrder>()
+ * );
+ *
+ * const productFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntitiesTrait<Product>()
+ * );
+ *
+ * const productMixedFactory = mixEntityFeatures({
+ *   products: productFeatureFactory,
+ *   productOrders: productOrderFeatureFactory,
+ *   clients: clientsFeatureFactory,
+ * });
+ *
+ * const mixedFeature = productMixedFactory({
+ *     actionsGroupKey: '[Mixed]',
+ *     featureSelector: 'mixed',
+ *   });
+ * mixedFeature.actions.loadClients();
+ * mixedFeature.actions.loadProducts();
+ *
+ */
 export declare function mixEntityFeatures<T extends {
     [key: string]: EntityFeatureFactory<any, any>;
 }, K extends keyof T, State extends {
     [P in K]: ExtractStateType<ReturnType<T[P]>>;
 }, A extends TraitActions & UnionToIntersection<ExtractActionsType<ReturnType<T[K]>>>, S extends TraitSelectors<any> & UnionToIntersection<FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[K]>>>>, R extends EntityFeatureFactory<any, any, State, A, S>>(traitFactoriesMap: T): R;
+/**
+ * Combines targetTraitFactory with the traitFactoriesMap using the keys as props for the targetTraitFactory state,
+ * and grouping the combined actions by key
+ * @param targetTraitFactory
+ * @param traitFactoriesMap
+ *
+ * @example
+ *
+ * const clientsFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'client', entitiesName: 'clients' },
+ *   addLoadEntitiesTrait<Client>(),
+ *   addCrudEntitiesTrait<Client>()
+ * );
+ *
+ * const productOrderFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'productOrder' },
+ *   addLoadEntitiesTrait<ProductOrder>(),
+ *   addSelectEntitiesTrait<ProductOrder>()
+ * );
+ *
+ * const productFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntitiesTrait<Product>()
+ * );
+ *
+ * const productAddEntityPropertiesFactory = addEntityFeaturesProperties(
+ *   productFeatureFactory,
+ *   {
+ *     productOrders: productOrderFeatureFactory,
+ *     clients: clientsFeatureFactory,
+ *   }
+ * );
+ *
+ * const combinedFeature = productAddEntityPropertiesFactory({
+ *     actionsGroupKey: '[addEntityFeatures]',
+ *     featureSelector: 'addEntityFeatures',
+ *   });
+ *
+ *   combinedFeature.actions.loadProducts();
+ *   combinedFeature.actions.clients.loadClients();
+ *   combinedFeature.actions.productOrders.loadProductOrders();
+ */
 export declare function addEntityFeaturesProperties<F extends EntityFeatureFactory<any, any>, T extends {
     [key: string]: EntityFeatureFactory<any, any, any, any, any>;
 }, K extends keyof T, State extends ExtractStateType<ReturnType<F>> & {
@@ -57,3 +213,18 @@ export declare function addEntityFeaturesProperties<F extends EntityFeatureFacto
     effects: Type<any>[];
     initialState: State;
 }>(targetTraitFactory: F, traitFactoriesMap: T): R;
+/**
+ * Helper function to create an implementation  a TraitFactory
+ * @param f TraitFactory implementation
+ */
+export declare function createTraitFactory<State = {}, A extends TraitActions = {}, S extends TraitSelectors<State> = {}, M extends TraitStateMutators<State> = {}, KEY extends string = string, C = unknown, KC = KeyedConfig<KEY, C>>(f: {
+    key: KEY;
+    config?: C;
+    depends?: string[];
+    actions?: TraitActionsFactory<A, KC>;
+    selectors?: TraitSelectorsFactory<State, S, KC>;
+    initialState?: TraitInitialStateFactory<State, KC>;
+    mutators?: TraitStateMutatorsFactory<State, M, KC>;
+    reducer?: TraitReducerFactory<State, A, S, M, KC>;
+    effects?: TraitEffectsFactory<State, A, S, KC>;
+}): TraitFactory<State, A, S, M, KEY, C, KC>;

package/esm2020/cache/cache.actions.mjs

@@ -0,0 +1,6 @@
+import { createAction, props } from '@ngrx/store';
+export const cache = createAction('[Cache] Cache', props());
+export const hitCache = createAction('[Cache] Hit Cache', props());
+export const invalidateCache = createAction('[Cache] Invalidate Cache', props());
+export const deleteCache = createAction('[Cache] Delete Cache', props());
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUuYWN0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmdyeC10cmFpdHMvY29yZS9zcmMvbGliL2NhY2hlL2NhY2hlLmFjdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFHbEQsTUFBTSxDQUFDLE1BQU0sS0FBSyxHQUFHLFlBQVksQ0FDL0IsZUFBZSxFQUNmLEtBQUssRUFNRCxDQUNMLENBQUM7QUFDRixNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsWUFBWSxDQUNsQyxtQkFBbUIsRUFDbkIsS0FBSyxFQUFxQixDQUMzQixDQUFDO0FBQ0YsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLFlBQVksQ0FDekMsMEJBQTBCLEVBQzFCLEtBQUssRUFBcUIsQ0FDM0IsQ0FBQztBQUNGLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxZQUFZLENBQ3JDLHNCQUFzQixFQUN0QixLQUFLLEVBQXFCLENBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjcmVhdGVBY3Rpb24sIHByb3BzIH0gZnJvbSAnQG5ncngvc3RvcmUnO1xuaW1wb3J0IHsgQ2FjaGVLZXkgfSBmcm9tICcuL2NhY2hlLm1vZGVscyc7XG5cbmV4cG9ydCBjb25zdCBjYWNoZSA9IGNyZWF0ZUFjdGlvbihcbiAgJ1tDYWNoZV0gQ2FjaGUnLFxuICBwcm9wczx7XG4gICAga2V5OiBDYWNoZUtleTtcbiAgICB2YWx1ZTogYW55O1xuICAgIGRhdGU6IG51bWJlcjtcbiAgICBtYXhDYWNoZVNpemU/OiBudW1iZXI7XG4gICAgZXhwaXJlcz86IG51bWJlcjtcbiAgfT4oKVxuKTtcbmV4cG9ydCBjb25zdCBoaXRDYWNoZSA9IGNyZWF0ZUFjdGlvbihcbiAgJ1tDYWNoZV0gSGl0IENhY2hlJyxcbiAgcHJvcHM8eyBrZXk6IENhY2hlS2V5IH0+KClcbik7XG5leHBvcnQgY29uc3QgaW52YWxpZGF0ZUNhY2hlID0gY3JlYXRlQWN0aW9uKFxuICAnW0NhY2hlXSBJbnZhbGlkYXRlIENhY2hlJyxcbiAgcHJvcHM8eyBrZXk6IENhY2hlS2V5IH0+KClcbik7XG5leHBvcnQgY29uc3QgZGVsZXRlQ2FjaGUgPSBjcmVhdGVBY3Rpb24oXG4gICdbQ2FjaGVdIERlbGV0ZSBDYWNoZScsXG4gIHByb3BzPHsga2V5OiBDYWNoZUtleSB9PigpXG4pO1xuIl19

package/esm2020/cache/cache.models.mjs

@@ -0,0 +1,30 @@
+function hash(key) {
+    return JSON.stringify(key, (_, val) => typeof val == 'object'
+        ? Object.keys(val)
+            .sort()
+            .reduce((result, k) => {
+            result[k] = val[k];
+            return result;
+        }, {})
+        : val);
+}
+export function hashKey(key) {
+    return typeof key === 'string'
+        ? [key]
+        : key.map((k) => {
+            return typeof k === 'string' ? k : hash(k);
+        });
+}
+export function getCacheValue(keys, state) {
+    let parent = state;
+    for (const key of keys) {
+        parent = parent?.keys?.[key];
+        if (!parent)
+            return undefined;
+    }
+    return parent?.data;
+}
+export function isCacheValid(cache, exp) {
+    return !cache.invalid && Date.now() <= cache.date + exp;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/cache/cache.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { StoreModule } from '@ngrx/store';
+import { cacheReducer } from './cache.reducer';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+export class CacheModule {
+}
+CacheModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CacheModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CacheModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CacheModule, imports: [i1.StoreFeatureModule] });
+CacheModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CacheModule, providers: [], imports: [[StoreModule.forFeature('cache', cacheReducer)]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CacheModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [StoreModule.forFeature('cache', cacheReducer)],
+                    providers: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZ3J4LXRyYWl0cy9jb3JlL3NyYy9saWIvY2FjaGUvY2FjaGUubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUMxQyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7OztBQU0vQyxNQUFNLE9BQU8sV0FBVzs7eUdBQVgsV0FBVzswR0FBWCxXQUFXOzBHQUFYLFdBQVcsYUFGWCxFQUFFLFlBREosQ0FBQyxXQUFXLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxZQUFZLENBQUMsQ0FBQzs0RkFHN0MsV0FBVztrQkFKdkIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxXQUFXLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxZQUFZLENBQUMsQ0FBQztvQkFDeEQsU0FBUyxFQUFFLEVBQUU7aUJBQ2QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU3RvcmVNb2R1bGUgfSBmcm9tICdAbmdyeC9zdG9yZSc7XG5pbXBvcnQgeyBjYWNoZVJlZHVjZXIgfSBmcm9tICcuL2NhY2hlLnJlZHVjZXInO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbU3RvcmVNb2R1bGUuZm9yRmVhdHVyZSgnY2FjaGUnLCBjYWNoZVJlZHVjZXIpXSxcbiAgcHJvdmlkZXJzOiBbXSxcbn0pXG5leHBvcnQgY2xhc3MgQ2FjaGVNb2R1bGUge31cbiJdfQ==

package/esm2020/cache/cache.reducer.mjs

@@ -0,0 +1,138 @@
+import { createReducer, on } from '@ngrx/store';
+import { hashKey, isCacheValid, } from './cache.models';
+import * as CacheActions from './cache.actions';
+export const initialState = {
+    keys: {},
+};
+export const cacheReducer = createReducer(initialState, on(CacheActions.cache, (state, { key, value, date, maxCacheSize }) => setCacheValue(hashKey(key), { value, date, invalid: false }, state, maxCacheSize)), on(CacheActions.invalidateCache, (state, { key }) => {
+    const k = hashKey(key);
+    return invalidateCache(k, state);
+}), on(CacheActions.deleteCache, (state, { key }) => {
+    const k = hashKey(key);
+    return deleteCacheValue(k, state);
+}), on(CacheActions.hitCache, (state, { key }) => {
+    const k = hashKey(key);
+    return increaseCacheHitCount(k, state);
+}));
+function setCacheValue(keys, value, state, maxCacheSize, expires) {
+    const newState = { ...state };
+    let cache = newState;
+    let lastCache = undefined;
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        cache.keys = cache?.keys ? { ...cache?.keys } : {};
+        let v = cache.keys[key];
+        v = v ? { ...v } : {};
+        cache.keys[key] = v;
+        lastCache = cache;
+        cache = v;
+    }
+    cache.data = cache.data
+        ? { ...value, hitCount: cache.data.hitCount + 1 }
+        : { ...value, hitCount: 1 };
+    if (maxCacheSize &&
+        lastCache?.keys &&
+        Object.keys(lastCache.keys).length > maxCacheSize) {
+        const entries = findLessHitOrOldestCacheEntries(lastCache, expires ?? Infinity, maxCacheSize);
+        if (entries && entries.length) {
+            for (const [key] of entries) {
+                delete lastCache.keys[key];
+            }
+        }
+    }
+    return newState;
+}
+function findLessHitOrOldestCacheEntries(state, expires, maxCacheSize) {
+    if (!state.keys)
+        return undefined;
+    const entries = Object.entries(state.keys);
+    // find the newest key;
+    const [newestKey] = entries.reduce((a, b) => {
+        const aDate = a[1].data?.date ?? 0;
+        const bDate = b[1].data?.date ?? 0;
+        return aDate > bDate ? a : b;
+    });
+    const sorted = entries.sort(([aKey, aValue], [bKey, bValue]) => {
+        // ensures the newest key always wins
+        if (aKey === newestKey)
+            return -1;
+        if (bKey === newestKey)
+            return 1;
+        const aValid = aValue.data && isCacheValid(aValue.data, expires) ? 1 : 0;
+        const bValid = bValue.data && isCacheValid(bValue.data, expires) ? 1 : 0;
+        const diffValid = aValid - bValid;
+        const diffHit = (aValue.data?.hitCount ?? 0) - (bValue.data?.hitCount ?? 0);
+        const diffDate = (aValue.data?.date ?? 0) - (bValue.data?.date ?? 0);
+        return (-1 * (diffValid === 0 ? (diffHit === 0 ? diffDate : diffHit) : diffValid));
+    });
+    return sorted.slice(maxCacheSize);
+}
+function deleteCacheValue(keys, state) {
+    const newState = { ...state };
+    let cache = newState;
+    for (const key of keys) {
+        if (!cache.keys)
+            return state;
+        cache.keys = { ...cache?.keys };
+        let v = cache.keys[key];
+        if (!v)
+            return state;
+        v = { ...v };
+        cache.keys[key] = v;
+        cache = v;
+    }
+    if (cache.data)
+        delete cache.data;
+    else if (cache.keys)
+        delete cache.keys;
+    return newState;
+}
+function invalidateCache(keys, state) {
+    const newState = { ...state };
+    let cache = newState;
+    for (const key of keys) {
+        if (!cache?.keys)
+            return state;
+        cache.keys = { ...cache?.keys };
+        let v = cache?.keys?.[key];
+        if (!v)
+            return state;
+        v = { ...v };
+        cache.keys[key] = v;
+        cache = v;
+    }
+    cache && invalidaSubKeys(cache);
+    return newState;
+}
+function increaseCacheHitCount(keys, state) {
+    const newState = { ...state };
+    let cache = newState;
+    for (const key of keys) {
+        if (!cache?.keys)
+            return state;
+        cache.keys = { ...cache?.keys };
+        let v = cache?.keys?.[key];
+        if (!v)
+            return state;
+        v = { ...v };
+        cache.keys[key] = v;
+        cache = v;
+    }
+    if (!cache.data)
+        return state;
+    cache.data = { ...cache.data, hitCount: cache.data.hitCount + 1 };
+    return newState;
+}
+function invalidaSubKeys(state) {
+    if (state.data) {
+        state.data = { ...state.data, invalid: true };
+    }
+    if (state.keys) {
+        state.keys = { ...state.keys };
+        for (const key in state.keys) {
+            state.keys[key] = invalidaSubKeys({ ...state.keys[key] });
+        }
+    }
+    return state;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache.reducer.js","sourceRoot":"","sources":["../../../../../../libs/ngrx-traits/core/src/lib/cache/cache.reducer.ts"],"names":[],"mappings":"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","sourcesContent":["import { createReducer, on } from '@ngrx/store';\nimport {\n  CacheData,\n  CacheKeys,\n  CacheState,\n  hashKey,\n  isCacheValid,\n} from './cache.models';\nimport * as CacheActions from './cache.actions';\n\nexport const initialState: CacheState = {\n  keys: {},\n};\n\nexport const cacheReducer = createReducer(\n  initialState,\n  on(CacheActions.cache, (state, { key, value, date, maxCacheSize }) =>\n    setCacheValue(\n      hashKey(key),\n      { value, date, invalid: false },\n      state,\n      maxCacheSize\n    )\n  ),\n  on(CacheActions.invalidateCache, (state, { key }) => {\n    const k = hashKey(key);\n    return invalidateCache(k, state);\n  }),\n  on(CacheActions.deleteCache, (state, { key }) => {\n    const k = hashKey(key);\n    return deleteCacheValue(k, state);\n  }),\n  on(CacheActions.hitCache, (state, { key }) => {\n    const k = hashKey(key);\n    return increaseCacheHitCount(k, state);\n  })\n);\n\nfunction setCacheValue(\n  keys: string[],\n  value: Omit<CacheData, 'hitCount'>,\n  state: CacheState,\n  maxCacheSize?: number,\n  expires?: number\n) {\n  const newState = { ...state };\n  let cache = newState;\n  let lastCache: CacheKeys | undefined = undefined;\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n    cache.keys = cache?.keys ? { ...cache?.keys } : {};\n    let v = cache.keys[key];\n    v = v ? { ...v } : {};\n    cache.keys[key] = v;\n    lastCache = cache;\n    cache = v;\n  }\n  cache.data = cache.data\n    ? { ...value, hitCount: cache.data.hitCount + 1 }\n    : { ...value, hitCount: 1 };\n\n  if (\n    maxCacheSize &&\n    lastCache?.keys &&\n    Object.keys(lastCache.keys).length > maxCacheSize\n  ) {\n    const entries = findLessHitOrOldestCacheEntries(\n      lastCache,\n      expires ?? Infinity,\n      maxCacheSize\n    );\n    if (entries && entries.length) {\n      for (const [key] of entries) {\n        delete lastCache.keys[key];\n      }\n    }\n  }\n  return newState;\n}\n\nfunction findLessHitOrOldestCacheEntries(\n  state: CacheKeys,\n  expires: number,\n  maxCacheSize: number\n) {\n  if (!state.keys) return undefined;\n  const entries = Object.entries(state.keys);\n  // find the newest key;\n  const [newestKey] = entries.reduce((a, b) => {\n    const aDate = a[1].data?.date ?? 0;\n    const bDate = b[1].data?.date ?? 0;\n    return aDate > bDate ? a : b;\n  });\n  const sorted = entries.sort(([aKey, aValue], [bKey, bValue]) => {\n    // ensures the newest key always wins\n    if (aKey === newestKey) return -1;\n    if (bKey === newestKey) return 1;\n    const aValid = aValue.data && isCacheValid(aValue.data, expires) ? 1 : 0;\n    const bValid = bValue.data && isCacheValid(bValue.data, expires) ? 1 : 0;\n    const diffValid = aValid - bValid;\n    const diffHit = (aValue.data?.hitCount ?? 0) - (bValue.data?.hitCount ?? 0);\n    const diffDate = (aValue.data?.date ?? 0) - (bValue.data?.date ?? 0);\n    return (\n      -1 * (diffValid === 0 ? (diffHit === 0 ? diffDate : diffHit) : diffValid)\n    );\n  });\n  return sorted.slice(maxCacheSize);\n}\n\nfunction deleteCacheValue(keys: string[], state: CacheState) {\n  const newState = { ...state };\n  let cache = newState;\n  for (const key of keys) {\n    if (!cache.keys) return state;\n    cache.keys = { ...cache?.keys };\n    let v = cache.keys[key];\n    if (!v) return state;\n    v = { ...v };\n    cache.keys[key] = v;\n    cache = v;\n  }\n  if (cache.data) delete cache.data;\n  else if (cache.keys) delete cache.keys;\n  return newState;\n}\n\nfunction invalidateCache(keys: string[], state: CacheState) {\n  const newState = { ...state };\n  let cache = newState;\n  for (const key of keys) {\n    if (!cache?.keys) return state;\n    cache.keys = { ...cache?.keys };\n    let v = cache?.keys?.[key];\n    if (!v) return state;\n    v = { ...v };\n    cache.keys[key] = v;\n    cache = v;\n  }\n  cache && invalidaSubKeys(cache);\n  return newState;\n}\n\nfunction increaseCacheHitCount(keys: string[], state: CacheState) {\n  const newState = { ...state };\n  let cache = newState;\n  for (const key of keys) {\n    if (!cache?.keys) return state;\n    cache.keys = { ...cache?.keys };\n    let v = cache?.keys?.[key];\n    if (!v) return state;\n    v = { ...v };\n    cache.keys[key] = v;\n    cache = v;\n  }\n  if (!cache.data) return state;\n  cache.data = { ...cache.data, hitCount: cache.data.hitCount + 1 };\n  return newState;\n}\n\nfunction invalidaSubKeys(state: CacheKeys) {\n  if (state.data) {\n    state.data = { ...state.data, invalid: true };\n  }\n  if (state.keys) {\n    state.keys = { ...state.keys };\n    for (const key in state.keys) {\n      state.keys[key] = invalidaSubKeys({ ...state.keys[key] });\n    }\n  }\n  return state;\n}\n"]}

package/esm2020/cache/cache.selectors.mjs

@@ -0,0 +1,5 @@
+import { createFeatureSelector, createSelector } from '@ngrx/store';
+import { getCacheValue, hashKey } from './cache.models';
+export const cacheStateSelector = createFeatureSelector('cache');
+export const selectCache = (key) => createSelector(cacheStateSelector, (state) => getCacheValue(hashKey(key), state));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUuc2VsZWN0b3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZ3J4LXRyYWl0cy9jb3JlL3NyYy9saWIvY2FjaGUvY2FjaGUuc2VsZWN0b3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxjQUFjLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDcEUsT0FBTyxFQUF3QixhQUFhLEVBQUUsT0FBTyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFOUUsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcscUJBQXFCLENBQWEsT0FBTyxDQUFDLENBQUM7QUFFN0UsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLENBQUMsR0FBYSxFQUFFLEVBQUUsQ0FDM0MsY0FBYyxDQUFDLGtCQUFrQixFQUFFLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FDM0MsYUFBYSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FDbkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNyZWF0ZUZlYXR1cmVTZWxlY3RvciwgY3JlYXRlU2VsZWN0b3IgfSBmcm9tICdAbmdyeC9zdG9yZSc7XG5pbXBvcnQgeyBDYWNoZUtleSwgQ2FjaGVTdGF0ZSwgZ2V0Q2FjaGVWYWx1ZSwgaGFzaEtleSB9IGZyb20gJy4vY2FjaGUubW9kZWxzJztcblxuZXhwb3J0IGNvbnN0IGNhY2hlU3RhdGVTZWxlY3RvciA9IGNyZWF0ZUZlYXR1cmVTZWxlY3RvcjxDYWNoZVN0YXRlPignY2FjaGUnKTtcblxuZXhwb3J0IGNvbnN0IHNlbGVjdENhY2hlID0gKGtleTogQ2FjaGVLZXkpID0+XG4gIGNyZWF0ZVNlbGVjdG9yKGNhY2hlU3RhdGVTZWxlY3RvciwgKHN0YXRlKSA9PlxuICAgIGdldENhY2hlVmFsdWUoaGFzaEtleShrZXkpLCBzdGF0ZSlcbiAgKTtcbiJdfQ==

package/esm2020/cache/cache.service.mjs

@@ -0,0 +1,72 @@
+import { of } from 'rxjs';
+import { isCacheValid } from './cache.models';
+import { selectCache } from './cache.selectors';
+import { concatMap, first, tap } from 'rxjs/operators';
+import * as CacheActions from './cache.actions';
+/**
+ * Cache the result of source parameter using the provided key, when call
+ * again if the cache is valid (exist and is not expired or invalidated)
+ * it will return the cache value without calling again source
+ * @example
+ * // cache for 3 min
+ * loadStores$ = createEffect(() => {
+ *   return this.actions$.pipe(
+ *     ofType(ProductStoreActions.loadStores),
+ *     exhaustMap(() =>
+ *       cache({
+ *         key: ['stores'],
+ *         store: this.store,
+ *         source: this.storeService.getStores(),
+ *         expire: 1000 * 60 * 3 // optional param , cache forever if not present
+ *       }).pipe(
+ *         map((res) => ProductStoreActions.loadStoresSuccess({ entities: res })),
+ *         catchError(() => of(ProductStoreActions.loadStoresFail()))
+ *       )
+ *     )
+ *   );
+ * });
+ * // cache top 10, for 3 mins
+ *   loadDepartments$ = createEffect(() => {
+ *   return this.actions$.pipe(
+ *     ofType(this.localActions.loadDepartments),
+ *     concatLatestFrom(() =>
+ *       this.store.select(this.localSelectors.selectDepartmentsFilter)
+ *     ),
+ *     exhaustMap(([_, filters]) =>
+ *       cache({
+ *         key: ['stores','departments',{ storeId: filters!.storeId },
+ *         store: this.store,
+ *         source: this.storeService.getStoreDepartments(filters!.storeId),
+ *         expires: 1000 * 60 * 3,
+ *         maxCacheSize: 10,
+ *       }).pipe(
+ *         map((res) =>
+ *           this.localActions.loadDepartmentsSuccess({
+ *             entities: res,
+ *           })
+ *         ),
+ *         catchError(() => of(this.localActions.loadDepartmentsFail()))
+ *       )
+ *     )
+ *   );
+ * });
+ *
+ * @param options - configuration
+ * @param options.store - required ngrx store
+ * @param options.key - key can be string, array of string or array of string with plain objects
+ * @param options.source - called when cache is invalid
+ * @param options.expires - time to expire the cache valued, if not present is infinite
+ * @param options.maxCacheSize - max number of keys to store , only works if last key is variable
+ */
+export function cache({ store, key, source, expires, maxCacheSize, skip, }) {
+    const exp = expires ?? Infinity;
+    return store.select(selectCache(key)).pipe(first(), concatMap((cache) => cache && !skip && isCacheValid(cache, exp)
+        ? of(cache.value).pipe(tap(() => store.dispatch(CacheActions.hitCache({ key }))))
+        : source.pipe(tap((value) => store.dispatch(CacheActions.cache({
+            key,
+            date: Date.now(),
+            value,
+            maxCacheSize,
+        }))))));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/cache/index.mjs

@@ -0,0 +1,7 @@
+export * from './cache.service';
+export * from './cache.module';
+import { invalidateCache, deleteCache } from './cache.actions';
+import { selectCache } from './cache.selectors';
+export const CacheActions = { invalidateCache, deleteCache };
+export const CacheSelectors = { getCache: selectCache };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25ncngtdHJhaXRzL2NvcmUvc3JjL2xpYi9jYWNoZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsT0FBTyxFQUFFLGVBQWUsRUFBRSxXQUFXLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDaEQsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLEVBQUUsZUFBZSxFQUFFLFdBQVcsRUFBRSxDQUFDO0FBQzdELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2FjaGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NhY2hlLm1vZHVsZSc7XG5pbXBvcnQgeyBpbnZhbGlkYXRlQ2FjaGUsIGRlbGV0ZUNhY2hlIH0gZnJvbSAnLi9jYWNoZS5hY3Rpb25zJztcbmltcG9ydCB7IHNlbGVjdENhY2hlIH0gZnJvbSAnLi9jYWNoZS5zZWxlY3RvcnMnO1xuZXhwb3J0IGNvbnN0IENhY2hlQWN0aW9ucyA9IHsgaW52YWxpZGF0ZUNhY2hlLCBkZWxldGVDYWNoZSB9O1xuZXhwb3J0IGNvbnN0IENhY2hlU2VsZWN0b3JzID0geyBnZXRDYWNoZTogc2VsZWN0Q2FjaGUgfTtcbiJdfQ==