@ngrx-traits/core 15.0.0 → 16.0.0

package/fesm2015/ngrx-traits-core.mjs

@@ -1,945 +0,0 @@
-import * as i1 from '@ngrx/store';
-import { createFeatureSelector, createReducer, createSelector, combineReducers, Store, ReducerManager, createAction, props, on, StoreModule } from '@ngrx/store';
-import * as i0 from '@angular/core';
-import { inject, Injectable, InjectionToken, Injector, NgModule } from '@angular/core';
-import { Actions, ofType, EffectSources } 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 Object.assign(Object.assign({}, 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 = Object.assign({}, 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 !== null && reducer !== void 0 ? 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) {
-    var _a;
-    const sortedTraits = [];
-    for (let i = 0; i < traits.length; i++) {
-        const trait = traits[i];
-        if (!((_a = trait.depends) === null || _a === void 0 ? void 0 : _a.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) => { var _a; return tr.key === ((_a = trait === null || trait === void 0 ? void 0 : trait.depends) === null || _a === void 0 ? void 0 : _a[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) => {
-        var _a, _b;
-        let result = (_b = (_a = factory === null || factory === void 0 ? void 0 : factory.actions) === null || _a === void 0 ? void 0 : _a.call(factory, {
-            actionsGroupKey: actionsGroupKey,
-            entityName,
-            entitiesName,
-            allConfigs,
-        })) !== null && _b !== void 0 ? _b : {};
-        result = previousResult ? Object.assign(Object.assign({}, previousResult), result) : result;
-        return result;
-    }, {});
-}
-function buildAllSelectors(sortedTraits, allConfigs) {
-    return sortedTraits.reduce((previousResult, factory) => {
-        var _a, _b;
-        let result = (_b = (_a = factory === null || factory === void 0 ? void 0 : factory.selectors) === null || _a === void 0 ? void 0 : _a.call(factory, {
-            previousSelectors: previousResult,
-            allConfigs,
-        })) !== null && _b !== void 0 ? _b : {};
-        result = previousResult ? Object.assign(Object.assign({}, previousResult), result) : result;
-        return result;
-    }, {});
-}
-function buildAllMutators(sortedTraits, allSelectors, allConfigs) {
-    return (sortedTraits.reduce((previousResult, factory) => {
-        var _a, _b;
-        let result = (_b = (_a = factory === null || factory === void 0 ? void 0 : factory.mutators) === null || _a === void 0 ? void 0 : _a.call(factory, {
-            allSelectors: allSelectors,
-            previousMutators: previousResult,
-            allConfigs,
-        })) !== null && _b !== void 0 ? _b : {};
-        result = previousResult ? Object.assign(Object.assign({}, previousResult), result) : result;
-        return result;
-    }, {}) || {});
-}
-function buildInitialState(sortedTraits, allConfigs) {
-    return sortedTraits.reduce((previousResult, factory) => {
-        var _a, _b, _c;
-        const result = (_c = (_b = (_a = factory === null || factory === void 0 ? void 0 : factory.initialState) === null || _a === void 0 ? void 0 : _a.call(factory, {
-            previousInitialState: previousResult,
-            allConfigs,
-        })) !== null && _b !== void 0 ? _b : previousResult) !== null && _c !== void 0 ? _c : {};
-        return result;
-    }, {});
-}
-function buildReducer(sortedTraits, initialState, allActions, allSelectors, allMutators, allConfigs) {
-    return sortedTraits.reduce((previousResult, factory) => {
-        var _a;
-        const result = (_a = factory === null || factory === void 0 ? void 0 : factory.reducer) === null || _a === void 0 ? void 0 : _a.call(factory, {
-            initialState,
-            allActions,
-            allSelectors,
-            allMutators,
-            allConfigs,
-        });
-        return result && previousResult
-            ? (state = initialState, action) => {
-                const aState = previousResult(state, action);
-                return result(aState, action);
-            }
-            : result !== null && result !== void 0 ? result : previousResult;
-    }, undefined);
-}
-function buildAllEffects(sortedTraits, allActions, allFeatureSelectors, allConfigs) {
-    return sortedTraits.reduce((previousResult, factory) => {
-        var _a, _b;
-        let result = (_b = (_a = factory === null || factory === void 0 ? void 0 : factory.effects) === null || _a === void 0 ? void 0 : _a.call(factory, {
-            allActions,
-            allSelectors: allFeatureSelectors,
-            allConfigs,
-        })) !== null && _b !== void 0 ? _b : [];
-        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 = Object.assign(Object.assign({}, actions), featureTraits.actions);
-            selectors = Object.assign(Object.assign({}, 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 = Object.assign({}, targetFeatureTraits.actions);
-        const selectors = Object.assign({}, 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;
-}
-/**
- * Helper function to combine selectors in components as map
- *
- * @example
- *
- * view = combineSelectors({
- *     products: ProductSelectors.selectProductsCurrentPage,
- *     isLoading: ProductSelectors.isLoadingProductsCurrentPage,
- *     selectedProduct: ProductSelectors.selectProductSelected,
- *     isLoadingCheckout: ProductSelectors.isLoadingCheckout,
- *     selectedSort: ProductSelectors.selectProductsSort,
- *     filters: ProductSelectors.selectProductsFilter,
- *   });
- * @param t
- */
-function combineSelectors(t) {
-    const selectors = Object.values(t);
-    const keys = Object.keys(t);
-    const projector = (...args) => keys.reduce((acc, key, index) => {
-        acc[key] = args[index];
-        return acc;
-    }, {});
-    return createSelector.apply(null, [...selectors, projector]);
-}
-
-class TraitEffect {
-    constructor() {
-        this.name = this.constructor.name;
-        this.componentId = '';
-        this.actions$ = inject(Actions);
-        this.store = inject((Store));
-    }
-    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: "15.2.10", ngImport: i0, type: TraitEffect, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-TraitEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TraitEffect });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TraitEffect, decorators: [{
-            type: Injectable
-        }] });
-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) {
-    var _a;
-    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,
-        });
-        (_a = traits.effects) === null || _a === void 0 ? void 0 : _a.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() {
-        super();
-        this.injector = inject(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: "15.2.10", ngImport: i0, type: TraitsLocalStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-TraitsLocalStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TraitsLocalStore });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TraitsLocalStore, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return []; } });
-
-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) {
-    var _a;
-    let parent = state;
-    for (const key of keys) {
-        parent = (_a = parent === null || parent === void 0 ? void 0 : parent.keys) === null || _a === void 0 ? void 0 : _a[key];
-        if (!parent)
-            return undefined;
-    }
-    return parent === null || parent === void 0 ? void 0 : 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 !== null && expires !== void 0 ? 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 = Object.assign({}, state);
-    let cache = newState;
-    let lastCache = undefined;
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        cache.keys = (cache === null || cache === void 0 ? void 0 : cache.keys) ? Object.assign({}, cache === null || cache === void 0 ? void 0 : cache.keys) : {};
-        let v = cache.keys[key];
-        v = v ? Object.assign({}, v) : {};
-        cache.keys[key] = v;
-        lastCache = cache;
-        cache = v;
-    }
-    cache.data = cache.data
-        ? Object.assign(Object.assign({}, value), { hitCount: cache.data.hitCount + 1 }) : Object.assign(Object.assign({}, value), { hitCount: 1 });
-    if (maxCacheSize &&
-        (lastCache === null || lastCache === void 0 ? void 0 : lastCache.keys) &&
-        Object.keys(lastCache.keys).length > maxCacheSize) {
-        const entries = findLessHitOrOldestCacheEntries(lastCache, expires !== null && expires !== void 0 ? 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) => {
-        var _a, _b, _c, _d;
-        const aDate = (_b = (_a = a[1].data) === null || _a === void 0 ? void 0 : _a.date) !== null && _b !== void 0 ? _b : 0;
-        const bDate = (_d = (_c = b[1].data) === null || _c === void 0 ? void 0 : _c.date) !== null && _d !== void 0 ? _d : 0;
-        return aDate > bDate ? a : b;
-    });
-    const sorted = entries.sort(([aKey, aValue], [bKey, bValue]) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        // 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 = ((_b = (_a = aValue.data) === null || _a === void 0 ? void 0 : _a.hitCount) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = bValue.data) === null || _c === void 0 ? void 0 : _c.hitCount) !== null && _d !== void 0 ? _d : 0);
-        const diffDate = ((_f = (_e = aValue.data) === null || _e === void 0 ? void 0 : _e.date) !== null && _f !== void 0 ? _f : 0) - ((_h = (_g = bValue.data) === null || _g === void 0 ? void 0 : _g.date) !== null && _h !== void 0 ? _h : 0);
-        return (-1 * (diffValid === 0 ? (diffHit === 0 ? diffDate : diffHit) : diffValid));
-    });
-    return sorted.slice(maxCacheSize);
-}
-function deleteCacheValue(keys, state) {
-    const newState = Object.assign({}, state);
-    let cache = newState;
-    for (const key of keys) {
-        if (!cache.keys)
-            return state;
-        cache.keys = Object.assign({}, cache === null || cache === void 0 ? void 0 : cache.keys);
-        let v = cache.keys[key];
-        if (!v)
-            return state;
-        v = Object.assign({}, 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) {
-    var _a;
-    const newState = Object.assign({}, state);
-    let cache = newState;
-    for (const key of keys) {
-        if (!(cache === null || cache === void 0 ? void 0 : cache.keys))
-            return state;
-        cache.keys = Object.assign({}, cache === null || cache === void 0 ? void 0 : cache.keys);
-        let v = (_a = cache === null || cache === void 0 ? void 0 : cache.keys) === null || _a === void 0 ? void 0 : _a[key];
-        if (!v)
-            return state;
-        v = Object.assign({}, v);
-        cache.keys[key] = v;
-        cache = v;
-    }
-    cache && invalidaSubKeys(cache);
-    return newState;
-}
-function increaseCacheHitCount(keys, state) {
-    var _a;
-    const newState = Object.assign({}, state);
-    let cache = newState;
-    for (const key of keys) {
-        if (!(cache === null || cache === void 0 ? void 0 : cache.keys))
-            return state;
-        cache.keys = Object.assign({}, cache === null || cache === void 0 ? void 0 : cache.keys);
-        let v = (_a = cache === null || cache === void 0 ? void 0 : cache.keys) === null || _a === void 0 ? void 0 : _a[key];
-        if (!v)
-            return state;
-        v = Object.assign({}, v);
-        cache.keys[key] = v;
-        cache = v;
-    }
-    if (!cache.data)
-        return state;
-    cache.data = Object.assign(Object.assign({}, cache.data), { hitCount: cache.data.hitCount + 1 });
-    return newState;
-}
-function invalidaSubKeys(state) {
-    if (state.data) {
-        state.data = Object.assign(Object.assign({}, state.data), { invalid: true });
-    }
-    if (state.keys) {
-        state.keys = Object.assign({}, state.keys);
-        for (const key in state.keys) {
-            state.keys[key] = invalidaSubKeys(Object.assign({}, state.keys[key]));
-        }
-    }
-    return state;
-}
-
-class CacheModule {
-}
-CacheModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CacheModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-CacheModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: CacheModule, imports: [i1.StoreFeatureModule] });
-CacheModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CacheModule, imports: [StoreModule.forFeature('cache', cacheReducer)] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", 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, combineSelectors, createEntityFeatureFactory, createTraitFactory, getDestroyActionName, insertIf, joinReducers, mixEntityFeatures, setPropertiesReducer, setPropertyReducer, toMap };
-//# sourceMappingURL=ngrx-traits-core.mjs.map