@ngrx-traits/core 12.1.2 → 13.0.0-beta.2

package/fesm2020/ngrx-traits-core.mjs

@@ -0,0 +1,915 @@
+import * as i2 from '@ngrx/store';
+import { createFeatureSelector, createReducer, createSelector, combineReducers, ReducerManager, Store, createAction, props, on, StoreModule } from '@ngrx/store';
+import * as i0 from '@angular/core';
+import { Injectable, InjectionToken, Injector, NgModule } from '@angular/core';
+import * as i1 from '@ngrx/effects';
+import { ofType, EffectSources, Actions } from '@ngrx/effects';
+import { takeUntil, first, concatMap, tap } from 'rxjs/operators';
+import { of } from 'rxjs';
+
+function insertIf(condition, getElement) {
+    return condition ? [getElement()] : [];
+}
+function toMap(a) {
+    return a.reduce((acum, value) => {
+        acum[value] = true;
+        return acum;
+    }, {});
+}
+function capitalize(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function camelCaseToSentence(text) {
+    const result = text.replace(/([A-Z])/g, ' $1');
+    return result.charAt(0).toUpperCase() + result.slice(1);
+}
+/**
+ * Set propertyReducer in sourceReducer in a property of the source state,
+ * @param sourceReducer
+ * @param property
+ * @param propertyReducer
+ *
+ * @example
+ *
+ * const newReducer = setPropertyReducer(productsReducer, 'selectedProduct', selectedProductReducer)
+ */
+function setPropertyReducer(sourceReducer, property, propertyReducer) {
+    return function reducer(state, action) {
+        const sourceState = sourceReducer(state, action);
+        return {
+            ...sourceState,
+            [property]: propertyReducer(sourceState[property], action),
+        };
+    };
+}
+/**
+ * Set propertyReducers in sourceReducer each in a property of the source state,
+ * @param sourceReducer
+ * @param property
+ * @param propertyReducer
+ *
+ * @example
+ *
+ * const newReducer = setPropertyReducer(productsReducer,
+ * {
+ *    selectedProduct: selectedProductReducer
+ *    favoriteProduct: favoriteProductReducer
+ * })
+ */
+function setPropertiesReducer(sourceReducer, propertiesReducers) {
+    return function reducer(state, action) {
+        const newState = { ...sourceReducer(state, action) };
+        for (const property in propertiesReducers) {
+            newState[property] = propertiesReducers[property](newState[property], action);
+        }
+        return newState;
+    };
+}
+/**
+ * joins two reducers so the work in the same state
+ * @param firstReducer
+ * @param secondReducer
+ */
+function joinReducers(firstReducer, secondReducer) {
+    return function reducer(state, action) {
+        const sourceState = firstReducer(state, action);
+        return secondReducer(sourceState, action);
+    };
+}
+
+/**
+ * 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',
+ * });
+ */
+function createEntityFeatureFactory(namesOrFactory, ...traits) {
+    return ((config) => {
+        const { entityName, entitiesName } = 'entityName' in namesOrFactory
+            ? namesOrFactory
+            : { entityName: 'Entity', entitiesName: 'Entities' };
+        const singular = capitalize(entityName);
+        const plural = entitiesName
+            ? capitalize(entitiesName)
+            : capitalize(entityName + 's');
+        const sortedTraits = sortTraits('entityName' in namesOrFactory ? [...traits] : [namesOrFactory, ...traits]);
+        const allConfigs = buildAllConfigs(sortedTraits);
+        const allActions = buildAllActions(sortedTraits, config.actionsGroupKey, singular, plural, allConfigs);
+        const allSelectors = buildAllSelectors(sortedTraits, allConfigs);
+        const allMutators = buildAllMutators(sortedTraits, allSelectors, allConfigs);
+        const initialState = buildInitialState(sortedTraits, allConfigs);
+        const reducer = buildReducer(sortedTraits, initialState, allActions, allSelectors, allMutators, allConfigs);
+        const featureSelector = typeof config.featureSelector === 'string'
+            ? createFeatureSelector(config.featureSelector)
+            : config.featureSelector;
+        const allFeatureSelectors = allSelectors && getSelectorsForFeature(featureSelector, allSelectors);
+        const allEffects = buildAllEffects(sortedTraits, allActions, allFeatureSelectors, allConfigs);
+        return {
+            actions: entityName
+                ? renameProps(allActions, singular, plural)
+                : allActions,
+            selectors: entityName
+                ? renameProps(allFeatureSelectors, singular, plural)
+                : allSelectors,
+            initialState,
+            reducer: reducer ?? createReducer(initialState),
+            effects: allEffects,
+        };
+    });
+}
+function renameProps(target, entityName, entitiesName) {
+    const result = {};
+    for (const [key, value] of Object.entries(target)) {
+        const newKey = key
+            .replace('Entities', entitiesName)
+            .replace('Entity', entityName);
+        result[newKey] = value;
+    }
+    return result;
+}
+function sortTraits(traits) {
+    const sortedTraits = [];
+    for (let i = 0; i < traits.length; i++) {
+        const trait = traits[i];
+        if (!trait.depends?.length) {
+            sortedTraits.push(trait);
+            continue;
+        }
+        if (trait.depends.length > 1)
+            for (const d of trait.depends) {
+                const isTraitPresent = traits.some((tr) => tr.key === d);
+                if (isTraitPresent) {
+                    trait.depends = [d];
+                    break;
+                }
+            }
+        if (trait.depends.length > 1)
+            throw Error('could not find dependencies ' + trait.depends.join(' '));
+        const isDependencyAlreadyAdded = sortedTraits.some((tr) => tr.key === trait?.depends?.[0]);
+        if (isDependencyAlreadyAdded)
+            sortedTraits.push(trait);
+        else {
+            // move trait to the end
+            delete traits[i];
+            traits.push(trait);
+        }
+    }
+    return sortedTraits;
+}
+function buildAllConfigs(sortedTraits) {
+    return sortedTraits.reduce((acc, factory) => {
+        acc[factory.key] = factory.config;
+        return acc;
+    }, {});
+}
+function buildAllActions(sortedTraits, actionsGroupKey, entityName, entitiesName, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        let result = factory?.actions?.({
+            actionsGroupKey: actionsGroupKey,
+            entityName,
+            entitiesName,
+            allConfigs,
+        }) ?? {};
+        result = previousResult ? { ...previousResult, ...result } : result;
+        return result;
+    }, {});
+}
+function buildAllSelectors(sortedTraits, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        let result = factory?.selectors?.({
+            previousSelectors: previousResult,
+            allConfigs,
+        }) ?? {};
+        result = previousResult ? { ...previousResult, ...result } : result;
+        return result;
+    }, {});
+}
+function buildAllMutators(sortedTraits, allSelectors, allConfigs) {
+    return (sortedTraits.reduce((previousResult, factory) => {
+        let result = factory?.mutators?.({
+            allSelectors: allSelectors,
+            previousMutators: previousResult,
+            allConfigs,
+        }) ?? {};
+        result = previousResult ? { ...previousResult, ...result } : result;
+        return result;
+    }, {}) || {});
+}
+function buildInitialState(sortedTraits, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        const result = factory?.initialState?.({
+            previousInitialState: previousResult,
+            allConfigs,
+        }) ??
+            previousResult ??
+            {};
+        return result;
+    }, {});
+}
+function buildReducer(sortedTraits, initialState, allActions, allSelectors, allMutators, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        const result = factory?.reducer?.({
+            initialState,
+            allActions,
+            allSelectors,
+            allMutators,
+            allConfigs,
+        });
+        return result && previousResult
+            ? (state = initialState, action) => {
+                const aState = previousResult(state, action);
+                return result(aState, action);
+            }
+            : result ?? previousResult;
+    }, undefined);
+}
+function buildAllEffects(sortedTraits, allActions, allFeatureSelectors, allConfigs) {
+    return sortedTraits.reduce((previousResult, factory) => {
+        let result = factory?.effects?.({
+            allActions,
+            allSelectors: allFeatureSelectors,
+            allConfigs,
+        }) ?? [];
+        result = previousResult ? [...previousResult, ...result] : result;
+        return result;
+    }, []);
+}
+function getSelectorsForFeature(featureSelect, selectors) {
+    const ss = {};
+    for (const prop in selectors) {
+        ss[prop] = createSelector(featureSelect, selectors[prop]);
+    }
+    return ss;
+}
+/**
+ * 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();
+ */
+function combineEntityFeatures(traitFactoriesMap) {
+    return ((config) => {
+        const featureSelector = typeof config.featureSelector === 'string'
+            ? createFeatureSelector(config.featureSelector)
+            : config.featureSelector;
+        const actions = {};
+        const selectors = {};
+        const reducers = {};
+        let effects = [];
+        for (const [key, entityFeatureFactory] of Object.entries(traitFactoriesMap)) {
+            const selector = createSelector(featureSelector, (state) => state[key]);
+            const featureTraits = entityFeatureFactory({
+                actionsGroupKey: config.actionsGroupKey,
+                featureSelector: selector,
+            });
+            actions[key] = featureTraits.actions;
+            selectors[key] = featureTraits.selectors;
+            reducers[key] = featureTraits.reducer;
+            effects = [...effects, ...featureTraits.effects];
+        }
+        return {
+            actions,
+            selectors,
+            reducer: combineReducers(reducers),
+            effects,
+        };
+    });
+}
+/**
+ * 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();
+ *
+ */
+function mixEntityFeatures(traitFactoriesMap) {
+    return ((config) => {
+        const featureSelector = typeof config.featureSelector === 'string'
+            ? createFeatureSelector(config.featureSelector)
+            : config.featureSelector;
+        let actions = {};
+        let selectors = {};
+        const reducers = {};
+        let effects = [];
+        for (const [key, entityFeatureFactory] of Object.entries(traitFactoriesMap)) {
+            const selector = createSelector(featureSelector, (state) => state[key]);
+            const featureTraits = entityFeatureFactory({
+                actionsGroupKey: config.actionsGroupKey,
+                featureSelector: selector,
+            });
+            actions = { ...actions, ...featureTraits.actions };
+            selectors = { ...selectors, ...featureTraits.selectors };
+            reducers[key] = featureTraits.reducer;
+            effects = [...effects, ...featureTraits.effects];
+        }
+        return {
+            actions,
+            selectors,
+            reducer: combineReducers(reducers),
+            effects,
+        };
+    });
+}
+/**
+ * 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();
+ */
+function addEntityFeaturesProperties(targetTraitFactory, traitFactoriesMap) {
+    return ((config) => {
+        const featureSelector = typeof config.featureSelector === 'string'
+            ? createFeatureSelector(config.featureSelector)
+            : config.featureSelector;
+        const targetFeatureTraits = targetTraitFactory({
+            actionsGroupKey: config.actionsGroupKey,
+            featureSelector: featureSelector,
+        });
+        const actions = { ...targetFeatureTraits.actions };
+        const selectors = { ...targetFeatureTraits.selectors };
+        const reducers = {};
+        let effects = [...targetFeatureTraits.effects];
+        for (const [key, entityFeatureFactory] of Object.entries(traitFactoriesMap)) {
+            const selector = createSelector(featureSelector, (state) => state[key]);
+            const featureTraits = entityFeatureFactory({
+                actionsGroupKey: config.actionsGroupKey,
+                featureSelector: selector,
+            });
+            actions[key] = featureTraits.actions;
+            selectors[key] = featureTraits.selectors;
+            reducers[key] = featureTraits.reducer;
+            effects = [...effects, ...featureTraits.effects];
+        }
+        return {
+            actions,
+            selectors,
+            reducer: setPropertiesReducer(targetFeatureTraits.reducer, reducers),
+            effects,
+        };
+    });
+}
+/**
+ * Helper function to create an implementation  a TraitFactory
+ * @param f TraitFactory implementation
+ */
+function createTraitFactory(f) {
+    return f;
+}
+
+class TraitEffect {
+    constructor(actions$, store) {
+        this.actions$ = actions$;
+        this.store = store;
+        this.name = this.constructor.name;
+        this.componentId = '';
+    }
+    ngrxOnIdentifyEffects() {
+        return this.componentId ? this.name + this.componentId : '';
+    }
+    ngrxOnRunEffects(resolvedEffects$) {
+        return this.componentId
+            ? resolvedEffects$.pipe(takeUntil(this.actions$.pipe(ofType(getDestroyActionName(this.componentId)))))
+            : resolvedEffects$;
+    }
+}
+TraitEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitEffect, deps: [{ token: i1.Actions }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+TraitEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitEffect });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitEffect, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Actions }, { type: i2.Store }]; } });
+function getDestroyActionName(id) {
+    return `[${id}] Destroyed`;
+}
+
+/**
+ * @ignore
+ * @internal
+ */
+const DISABLE_LOCAL_TRAIT_EFFECTS = new InjectionToken('disableLocalTraitEffects');
+
+let id = 0;
+function uniqueComponentId() {
+    return id++;
+}
+/**
+ * Builds traitFactory and registers effects and reducers with
+ * a generated component id, returns build actions and selectors
+ * and a destroy method that will unergister the effects and reducers
+ * when called, and a addEffect which can be use to register extra effects
+ *
+ * Used inside TraitsLocalStore, can be used to create your
+ * own Component Service without extending TraitsLocalStore
+ * @param injector
+ * @param componentName
+ * @param traitFactory
+ */
+function buildLocalTraits(injector, componentName, traitFactory) {
+    const reducers = injector.get(ReducerManager);
+    const effects = injector.get(EffectSources);
+    const store = injector.get(Store);
+    const componentId = `${componentName}_${uniqueComponentId()}`;
+    const traits = traitFactory({
+        featureSelector: createFeatureSelector(componentId),
+        actionsGroupKey: `[${componentId}]`,
+    });
+    traits.reducer && reducers.addReducer(componentId, traits.reducer);
+    const providers = (traits.effects && [...traits.effects.map((e) => ({ provide: e }))]) || [];
+    const disableLocalTraitsEffects = injector.get(DISABLE_LOCAL_TRAIT_EFFECTS, false);
+    if (!disableLocalTraitsEffects) {
+        const i = Injector.create({
+            providers: providers,
+            parent: injector,
+        });
+        traits.effects?.forEach((e) => {
+            const effect = i.get(e);
+            effect.componentId = componentId;
+            effects.addEffects(effect);
+        });
+    }
+    function destroy() {
+        store.dispatch({ type: getDestroyActionName(componentId) });
+        /**
+         * A service that extends TraitsLocalStore and other component service are destroyed
+         * before the component that depends on them, this causes that any subscriptions
+         * to selectors of the TraitsLocalStore could fail because the store state is removed before
+         * they are unsubscribe by the onDestroy of the component. Executing reducers.removeReducer
+         * inside setTimeout ensures the state is remove after the component onDestroy was called,
+         * avoiding the before mentioned possible issues.
+         */
+        setTimeout(() => reducers.removeReducer(componentId));
+    }
+    return {
+        destroy,
+        actions: traits.actions,
+        selectors: traits.selectors,
+        addEffects(localEffect) {
+            localEffect.componentId = componentId;
+            effects.addEffects(localEffect);
+        },
+    };
+}
+/**
+ * Class used to create local traits service, receives a trait factory, which will be
+ * built and its reducers and effect register using a dynamic id when the service is built
+ * and get destroyed when the onDestroy lifecycle method of the service is called, if the service
+ * has effects this.traits.addEffects(this) should be call in the constructor
+ *
+ * @example
+ * const productFeatureFactory = createEntityFeatureFactory(
+ *   { entityName: 'product' },
+ *   addLoadEntitiesTrait<Product>(),
+ *   addSelectEntityTrait<Product>(),
+ * );
+ *
+ * Injectable()
+ * export class ProductsLocalTraits extends TraitsLocalStore<
+ *   typeof productFeatureFactory
+ * > {
+ *   loadProducts$ = createEffect(() =>
+ *     this.actions$.pipe(
+ *       ofType(this.localActions.loadProducts),
+ *       switchMap(() =>
+ *         //call your service to get the products data
+ *         this.productService.getProducts().pipe(
+ *           map((res) =>
+ *             this.localActions.loadProductsSuccess({ entities: res.resultList })
+ *           ),
+ *           catchError(() => of(this.localActions.loadProductsFail()))
+ *         )
+ *       )
+ *     )
+ *   );
+ *
+ *   constructor(injector: Injector, private productService: ProductService) {
+ *     super(injector);
+ *     this.traits.addEffects(this); // IMPORTANT! add this line if the service has effects
+ *   }
+ *
+ *   setup(): LocalTraitsConfig<typeof productFeatureFactory> {
+ *     return {
+ *       componentName: 'ProductsPickerComponent',
+ *       traitsFactory: productFeatureFactory,
+ *     };
+ *   }
+ * }
+ *
+ * // use in component later
+ *
+ * Component({
+ *   selector: 'some-component',
+ *   template: `<div> some content</div> `,
+ *   providers: [ProductsLocalTraits],
+ *   changeDetection: ChangeDetectionStrategy.OnPush,
+ * })
+ * export class ProductSelectDialogComponent implements OnInit {
+ *   constructor(private store: Store, private traits: ProductsLocalTraits) {}
+ *
+ *   ngOnInit() {
+ *     this.store.dispatch(this.traits.localActions.loadProducts());
+ *   }
+ * }
+ */
+class TraitsLocalStore extends TraitEffect {
+    constructor(injector) {
+        super(injector.get(Actions), injector.get(Store));
+        this.injector = injector;
+        const config = this.setup();
+        this.traits = buildLocalTraits(this.injector, config.componentName, config.traitsFactory);
+        this.localActions = this.traits.actions;
+        this.localSelectors = this.traits.selectors;
+    }
+    ngOnDestroy() {
+        this.traits.destroy();
+    }
+}
+TraitsLocalStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitsLocalStore, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+TraitsLocalStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitsLocalStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TraitsLocalStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+
+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);
+}
+function hashKey(key) {
+    return typeof key === 'string'
+        ? [key]
+        : key.map((k) => {
+            return typeof k === 'string' ? k : hash(k);
+        });
+}
+function getCacheValue(keys, state) {
+    let parent = state;
+    for (const key of keys) {
+        parent = parent?.keys?.[key];
+        if (!parent)
+            return undefined;
+    }
+    return parent?.data;
+}
+function isCacheValid(cache, exp) {
+    return !cache.invalid && Date.now() <= cache.date + exp;
+}
+
+const cacheStateSelector = createFeatureSelector('cache');
+const selectCache = (key) => createSelector(cacheStateSelector, (state) => getCacheValue(hashKey(key), state));
+
+const cache$1 = createAction('[Cache] Cache', props());
+const hitCache = createAction('[Cache] Hit Cache', props());
+const invalidateCache$1 = createAction('[Cache] Invalidate Cache', props());
+const deleteCache = createAction('[Cache] Delete Cache', props());
+
+/**
+ * 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
+ */
+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(hitCache({ key }))))
+        : source.pipe(tap((value) => store.dispatch(cache$1({
+            key,
+            date: Date.now(),
+            value,
+            maxCacheSize,
+        }))))));
+}
+
+const initialState = {
+    keys: {},
+};
+const cacheReducer = createReducer(initialState, on(cache$1, (state, { key, value, date, maxCacheSize }) => setCacheValue(hashKey(key), { value, date, invalid: false }, state, maxCacheSize)), on(invalidateCache$1, (state, { key }) => {
+    const k = hashKey(key);
+    return invalidateCache(k, state);
+}), on(deleteCache, (state, { key }) => {
+    const k = hashKey(key);
+    return deleteCacheValue(k, state);
+}), on(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;
+}
+
+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: [i2.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: [],
+                }]
+        }] });
+
+const CacheActions = { invalidateCache: invalidateCache$1, deleteCache };
+const CacheSelectors = { getCache: selectCache };
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CacheActions, CacheModule, CacheSelectors, DISABLE_LOCAL_TRAIT_EFFECTS, TraitEffect, TraitsLocalStore, addEntityFeaturesProperties, buildLocalTraits, cache, camelCaseToSentence, capitalize, combineEntityFeatures, createEntityFeatureFactory, createTraitFactory, getDestroyActionName, insertIf, joinReducers, mixEntityFeatures, setPropertiesReducer, setPropertyReducer, toMap };
+//# sourceMappingURL=ngrx-traits-core.mjs.map