@ngrx-traits/core 0.0.1

package/fesm2015/ngrx-traits-core.js

@@ -0,0 +1,699 @@
+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);
+}
+
+function createTraitFactory(f) {
+    return f;
+}
+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;
+}
+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) });
+    };
+}
+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;
+    };
+}
+function joinReducers(firstReducer, secondReducer) {
+    return function reducer(state, action) {
+        const sourceState = firstReducer(state, action);
+        return secondReducer(sourceState, action);
+    };
+}
+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,
+        };
+    });
+}
+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,
+        };
+    });
+}
+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,
+        };
+    });
+}
+// export
+/// products:{actions, selectors, }, orders: {actions,slectors}
+/// { actions: {ProductActions, OrderActions}, selectors: {ProductSelectors, OrderSelectors}
+// TODO finish implementing combineTrais and addPropertiesTraits
+// TODO finish renaming traits
+
+// type G = ReplaceProps<
+//   ReplaceProps<
+//     {
+//       loadEntities: 1;
+//       loadEntitiesSuccess: 2;
+//       selectEntities: 3;
+//       selectEntity: 4;
+//     },
+//     'Entities',
+//     'products'
+//   >,
+//   'Entity',
+//   'product'
+// >;
+//
+// const g: G = {};
+// // g.
+//   type F= ReplaceEntityNames<{
+//   loadEntities: 1;
+//   loadEntitiesSuccess: 2;
+//   selectEntities: 3;
+//   selectEntity: 4;
+// }, 'product','products'>;
+// const f: F = {};
+// f.
+// TODO clean up file
+
+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: "12.1.2", ngImport: i0, type: TraitEffect, deps: [{ token: i1.Actions }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+TraitEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: TraitEffect });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: TraitEffect, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Actions }, { type: i2.Store }]; } });
+function getDestroyActionName(id) {
+    return `[${id}] Destroyed`;
+}
+
+/**
+ * @internal
+ */
+const DISABLE_LOCAL_TRAIT_EFFECTS = new InjectionToken('disableLocalTraitEffects');
+
+let id = 0;
+function uniqueComponentId() {
+    return id++;
+}
+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 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: "12.1.2", ngImport: i0, type: TraitsLocalStore, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+TraitsLocalStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: TraitsLocalStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", 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) {
+    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, }) {
+    const exp = expires !== null && expires !== void 0 ? expires : Infinity;
+    return store.select(selectCache(key)).pipe(first(), concatMap((cache) => cache && 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: "12.1.2", ngImport: i0, type: CacheModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CacheModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: CacheModule, imports: [i2.StoreFeatureModule] });
+CacheModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: CacheModule, providers: [], imports: [[StoreModule.forFeature('cache', cacheReducer)]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", 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.js.map