@ngrx-traits/common 0.0.1

package/fesm2015/ngrx-traits-common.js

@@ -0,0 +1,1511 @@
+import * as i2 from '@ngrx/store';
+import { createReducer, on, createAction, props, createSelector } from '@ngrx/store';
+import { insertIf, createTraitFactory, TraitEffect, toMap, camelCaseToSentence, capitalize } from '@ngrx-traits/core';
+import { createEntityAdapter } from '@ngrx/entity';
+import * as i0 from '@angular/core';
+import { Injectable } from '@angular/core';
+import { asyncScheduler, EMPTY, timer, of, pipe } from 'rxjs';
+import { debounce, concatMap, first, map, distinctUntilChanged, startWith, pairwise, concatMapTo, filter, mapTo } from 'rxjs/operators';
+import * as i1 from '@ngrx/effects';
+import { createEffect, ofType, concatLatestFrom } from '@ngrx/effects';
+import { __rest } from 'tslib';
+
+const loadEntitiesTraitKey = 'loadEntities';
+
+function createLoadEntitiesInitialState(previousInitialState = {}, allConfigs) {
+    const traitConfig = allConfigs.loadEntities;
+    const adapter = traitConfig.adapter;
+    return Object.assign(Object.assign(Object.assign({}, previousInitialState), adapter.getInitialState()), { status: undefined });
+}
+function createLoadEntitiesTraitReducer(initialState, actions, allMutators, allConfigs) {
+    const handleEntitiesMerge = !(allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.pagination);
+    return createReducer(initialState, on(actions.loadEntities, (state) => (Object.assign(Object.assign({}, state), { status: 'loading' }))), on(actions.loadEntitiesFail, (state) => (Object.assign(Object.assign({}, state), { status: 'fail' }))), on(actions.loadEntitiesSuccess, (state) => (Object.assign(Object.assign({}, state), { status: 'success' }))), ...insertIf(handleEntitiesMerge, () => on(actions.loadEntitiesSuccess, (state, { entities }) => allMutators.setEntitiesList(entities, Object.assign({}, state)))));
+}
+
+function createLoadEntitiesTraitMutators(allConfigs) {
+    var _a;
+    const adapter = (_a = allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.loadEntities) === null || _a === void 0 ? void 0 : _a.adapter;
+    return {
+        setEntitiesList: adapter === null || adapter === void 0 ? void 0 : adapter.setAll,
+    };
+}
+
+function createLoadEntitiesTraitActions(actionsGroupKey, entitiesName) {
+    const actions = {
+        loadEntities: createAction(`${actionsGroupKey} Load ${entitiesName}`),
+        loadEntitiesSuccess: createAction(`${actionsGroupKey} Load ${entitiesName} Success`, props()),
+        loadEntitiesFail: createAction(`${actionsGroupKey} Load ${entitiesName} Fail`, (props) => ({ error: props === null || props === void 0 ? void 0 : props.error })),
+    };
+    return actions;
+}
+
+function isLoading(state) {
+    return state.status === 'loading';
+}
+function isSuccess(state) {
+    return state.status === 'success';
+}
+function isFail(state) {
+    return state.status === 'fail';
+}
+
+function selectEntitiesFilter(state) {
+    return state.filters;
+}
+function createFilterTraitSelectors() {
+    return {
+        selectEntitiesFilter,
+    };
+}
+
+function createLoadEntitiesTraitSelectors(allConfigs) {
+    var _a, _b;
+    const adapter = (_a = allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.loadEntities) === null || _a === void 0 ? void 0 : _a.adapter;
+    const entitySelectors = adapter.getSelectors();
+    const filterFunction = (_b = allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.filter) === null || _b === void 0 ? void 0 : _b.filterFn;
+    let selectors = {
+        selectEntitiesList: entitySelectors.selectAll,
+        selectEntitiesMap: entitySelectors.selectEntities,
+        selectEntitiesIdsList: entitySelectors.selectIds,
+        selectEntitiesTotal: entitySelectors.selectTotal,
+        isEntitiesLoadingFail: isFail,
+        isEntitiesLoading: isLoading,
+        isEntitiesLoadingSuccess: isSuccess,
+    };
+    if (filterFunction && entitySelectors) {
+        const selectEntitiesList = createSelector(entitySelectors.selectAll, selectEntitiesFilter, (entities, filters) => filters ? entities.filter((e) => filterFunction(filters, e)) : entities);
+        selectors = Object.assign(Object.assign({}, selectors), { selectEntitiesList, selectEntitiesMap: createSelector(selectors.selectEntitiesMap, selectEntitiesFilter, (entities, filters) => {
+                const result = {};
+                for (const id in entities) {
+                    const e = entities[id];
+                    if (filterFunction(filters, e)) {
+                        result[id] = e;
+                    }
+                }
+                return result;
+            }), selectEntitiesTotal: createSelector(selectEntitiesList, (entities) => entities.length), selectEntitiesIdsList: createSelector(selectEntitiesList, (entities) => entities.map((e) => adapter === null || adapter === void 0 ? void 0 : adapter.selectId(e))) });
+    }
+    return selectors;
+}
+
+/**
+ * Generates the ngrx code needed to load a list of entities from the backend
+ * with a load[EntitiesName], load[EntitiesName]Success, load[EntitiesName]Fail actions, and selectors to query the
+ * entities like selectEntity[EntitiesName]List, selectEntity[EntitiesName]Ids, selectEntity[EntitiesName]Map, and its progress loading
+ * with isLoading[EntitiesName],isLoading[EntitiesName]Success, isLoading[EntitiesName]Fail. This trait is the base for all other traits related
+ * to a list of entities, the other will call loadEntities when needing data.
+ * @param traitConfig - Config object fot the trait factory
+ * @param traitConfig.selectId - Function that returns the id of an entity
+ * @param traitConfig.sortComparer - Default sort function for to @ngrx/entity EntityAdapter
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends LoadEntitiesState<Todo>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate the actions and selectors
+ * traits.actions.loadTodos()
+ * traits.actions.loadTodosSuccess({entities: todos})
+ * traits.actions.loadTodosFail();
+ * traits.selectors.selectTodosList
+ * traits.selectors.selectTodosMap
+ * traits.selectors.selectTodosIds
+ * traits.selectors.selectTodosTotal
+ * traits.selectors.isLoadingTodos
+ * traits.selectors.isSuccessTodosSuccess
+ * traits.selectors.isFailTodosFail
+ */
+function addLoadEntitiesTrait(traitConfig) {
+    const adapter = createEntityAdapter(traitConfig);
+    return createTraitFactory({
+        key: loadEntitiesTraitKey,
+        config: Object.assign(Object.assign({}, traitConfig), { adapter }),
+        actions: ({ actionsGroupKey, entitiesName }) => createLoadEntitiesTraitActions(actionsGroupKey, entitiesName),
+        selectors: ({ allConfigs }) => createLoadEntitiesTraitSelectors(allConfigs),
+        mutators: ({ allConfigs }) => createLoadEntitiesTraitMutators(allConfigs),
+        initialState: ({ previousInitialState, allConfigs, }) => createLoadEntitiesInitialState(previousInitialState, allConfigs),
+        reducer: ({ initialState, allActions, allMutators, allConfigs }) => createLoadEntitiesTraitReducer(initialState, allActions, allMutators, allConfigs),
+    });
+}
+
+const entitiesPaginationTraitKey = 'pagination';
+
+function createFilterTraitEffects(allActions, allSelectors, allConfigs) {
+    const traitConfig = allConfigs.filter;
+    class FilterEffect extends TraitEffect {
+        constructor() {
+            super(...arguments);
+            this.storeFilter$ = createEffect(() => ({ debounce: debounceTime = traitConfig.defaultDebounceTime, scheduler = asyncScheduler, } = {}) => this.actions$.pipe(ofType(allActions.filterEntities), debounce((value) => (value === null || value === void 0 ? void 0 : value.forceLoad) ? EMPTY : timer(debounceTime, scheduler)), concatMap((payload) => payload.patch
+                ? this.store.select(allSelectors.selectEntitiesFilter).pipe(first(), map((storedFilters) => (Object.assign(Object.assign({}, payload), { filters: Object.assign(Object.assign({}, storedFilters), payload === null || payload === void 0 ? void 0 : payload.filters) }))))
+                : of(payload)), distinctUntilChanged((previous, current) => !(current === null || current === void 0 ? void 0 : current.forceLoad) &&
+                JSON.stringify(previous === null || previous === void 0 ? void 0 : previous.filters) ===
+                    JSON.stringify(current === null || current === void 0 ? void 0 : current.filters)), (traitConfig === null || traitConfig === void 0 ? void 0 : traitConfig.isRemoteFilter)
+                ? pipe(startWith({
+                    filters: traitConfig.defaultFilter,
+                    patch: false,
+                }), pairwise(), concatMap(([previous, current]) => (traitConfig === null || traitConfig === void 0 ? void 0 : traitConfig.isRemoteFilter(previous === null || previous === void 0 ? void 0 : previous.filters, current === null || current === void 0 ? void 0 : current.filters))
+                    ? [
+                        allActions.storeEntitiesFilter({
+                            filters: current === null || current === void 0 ? void 0 : current.filters,
+                            patch: current === null || current === void 0 ? void 0 : current.patch,
+                        }),
+                        allActions.loadEntities(),
+                    ]
+                    : [
+                        allActions.storeEntitiesFilter({
+                            filters: current === null || current === void 0 ? void 0 : current.filters,
+                            patch: current === null || current === void 0 ? void 0 : current.patch,
+                        }),
+                    ]))
+                : map((action) => allActions.storeEntitiesFilter({
+                    filters: action === null || action === void 0 ? void 0 : action.filters,
+                    patch: action === null || action === void 0 ? void 0 : action.patch,
+                }))));
+            this.loadEntities$ = (!(traitConfig === null || traitConfig === void 0 ? void 0 : traitConfig.filterFn) || (traitConfig === null || traitConfig === void 0 ? void 0 : traitConfig.isRemoteFilter)) &&
+                createEffect(() => {
+                    return this.actions$.pipe(ofType(allActions['storeEntitiesFilter']), concatMap(() => (allActions === null || allActions === void 0 ? void 0 : allActions.loadEntitiesFirstPage)
+                        ? [
+                            allActions.clearEntitiesPagesCache(),
+                            allActions.loadEntitiesFirstPage(),
+                        ]
+                        : [allActions.loadEntities()]));
+                });
+        }
+    }
+    FilterEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: FilterEffect, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    FilterEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: FilterEffect });
+    i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: FilterEffect, decorators: [{
+                type: Injectable
+            }] });
+    return [FilterEffect];
+}
+
+function createFilterInitialState(previousInitialState, allConfigs) {
+    var _a;
+    return Object.assign(Object.assign({}, previousInitialState), { filters: (_a = allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.filter) === null || _a === void 0 ? void 0 : _a.defaultFilter });
+}
+function createFilterTraitReducer(initialState, allActions, allMutators) {
+    return createReducer(initialState, on(allActions.storeEntitiesFilter, (state, { filters }) => allMutators.setEntitiesFilters(filters, state)));
+}
+
+const filterEntitiesTraitKey = 'filter';
+
+function createFilterTraitMutators() {
+    function setEntitiesFilters(filters, state) {
+        return Object.assign(Object.assign({}, state), { filters });
+    }
+    return { setEntitiesFilters };
+}
+
+function createFilterTraitActions(actionsGroupKey, entitiesName) {
+    const actions = {
+        filterEntities: createAction(`${actionsGroupKey} Filter ${entitiesName}`, (props) => ({
+            filters: props === null || props === void 0 ? void 0 : props.filters,
+            forceLoad: props === null || props === void 0 ? void 0 : props.forceLoad,
+            patch: props === null || props === void 0 ? void 0 : props.patch,
+        })),
+        storeEntitiesFilter: createAction(`${actionsGroupKey} Store ${entitiesName} Filter`, (props) => ({
+            filters: props === null || props === void 0 ? void 0 : props.filters,
+            patch: props === null || props === void 0 ? void 0 : props.patch,
+        })),
+    };
+    return actions;
+}
+
+/**
+ * Generates the ngrx code needed to filter a list of entities locally or remotely, adds a filter
+ * action and a selectFilter selector, the filter action is debounced and the filter will only
+ * call the loadEntities action if the params have changed, so there is no need to implement that in
+ * the components. The filter action has a `forceLoad` param which can
+ * be use to skip that restriction for one call or setting the `defaultDebounceTime` to 0 for all calls.
+ * Calling the filter action will also replace the `filters` param in the store, if the `patch` param is set
+ * the filters are merged with the previous value in the store.
+ * @param traitConfig - Config object fot the trait factory
+ * @param traitConfig.defaultFilter - Initial value for the filter
+ * @param traitConfig.filterFn - Function to filter entities in memory, if not present then its expected
+ * is filtered by the backend unless isRemoteFilter is defned
+ * @param traitConfig.defaultDebounceTime - Value in milliseconds. Default to 400ms
+ * @param traitConfig.isRemoteFilter - Function to when it returns true it fires loadEntities so a remote
+ * backend filtering can run, otherwise it uses filterFn to do a local filtering
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,FilterState<TodoFilter>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      //addFilterEntitiesTrait<Todo,TodoFilter>() // no params uses remote filtering
+ *      addFilterEntitiesTrait<Todo,TodoFilter>({filterFn: (filter, entity) => // local filtering
+ *          filter?.content && entity.content?.includes(filter?.content) || false})
+ *          // or use the following function to switch between remote search and local
+ *          // depending on which properties have changed in the filter
+ *          // isRemoteFilter: (previous, current) => previous?.someRemoteParam !== current?.someRemoteParam,
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions and selectors, plus the ones generated by other traits
+ * traits.actions.filterTodos()
+ * traits.selectors.selectTodosFilter()
+ */
+function addFilterEntitiesTrait({ defaultDebounceTime = 400, defaultFilter, filterFn, isRemoteFilter, } = {}) {
+    return createTraitFactory({
+        key: filterEntitiesTraitKey,
+        depends: [entitiesPaginationTraitKey, loadEntitiesTraitKey],
+        config: {
+            defaultDebounceTime,
+            defaultFilter,
+            filterFn,
+            isRemoteFilter,
+        },
+        actions: ({ actionsGroupKey, entitiesName }) => createFilterTraitActions(actionsGroupKey, entitiesName),
+        selectors: () => createFilterTraitSelectors(),
+        mutators: () => createFilterTraitMutators(),
+        initialState: ({ previousInitialState, allConfigs, }) => createFilterInitialState(previousInitialState, allConfigs),
+        reducer: ({ initialState, allActions, allMutators }) => createFilterTraitReducer(initialState, allActions, allMutators),
+        effects: ({ allActions, allSelectors, allConfigs }) => createFilterTraitEffects(allActions, allSelectors, allConfigs),
+    });
+}
+
+function createPaginationTraitSelectors(previousSelectors, allConfigs) {
+    var _a;
+    const { selectEntitiesList, isEntitiesLoading } = previousSelectors;
+    const filterFunction = (_a = allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.filter) === null || _a === void 0 ? void 0 : _a.filterFn;
+    function selectPagination(state) {
+        return state.pagination;
+    }
+    const selectPaginationFiltered = filterFunction
+        ? createSelector(selectEntitiesList, selectPagination, (entities, pagination) => {
+            return Object.assign(Object.assign({}, pagination), { total: entities.length, cache: Object.assign(Object.assign({}, pagination.cache), { start: 0, end: entities.length }) });
+        })
+        : selectPagination;
+    const selectPageEntitiesList = createSelector(selectEntitiesList, selectPaginationFiltered, (entities, pagination, { page } = { page: pagination.currentPage }) => {
+        const startIndex = page * pagination.pageSize - pagination.cache.start;
+        let endIndex = startIndex + pagination.pageSize;
+        endIndex =
+            endIndex < pagination.cache.end ? endIndex : pagination.cache.end;
+        return entities.slice(startIndex, endIndex);
+    });
+    const selectEntitiesPageInfo = createSelector(selectPaginationFiltered, (pagination) => {
+        const pagesCount = pagination.total && pagination.total > 0
+            ? Math.ceil(pagination.total / pagination.pageSize)
+            : undefined;
+        return {
+            pageIndex: pagination.currentPage,
+            total: pagination.total,
+            pageSize: pagination.pageSize,
+            pagesCount,
+            hasPrevious: pagination.currentPage - 1 >= 0,
+            hasNext: pagination.total && pagination.total > 0
+                ? pagination.currentPage + 1 < pagesCount
+                : true,
+            cacheType: pagination.cache.type,
+        };
+    });
+    const isEntitiesPageInCache = createSelector(selectPaginationFiltered, (pagination, { page } = { page: pagination.currentPage }) => {
+        const startIndex = page * pagination.pageSize;
+        let endIndex = startIndex + pagination.pageSize - 1;
+        endIndex =
+            pagination.total && endIndex > pagination.total
+                ? pagination.total - 1
+                : endIndex;
+        return (startIndex >= pagination.cache.start && endIndex <= pagination.cache.end);
+    });
+    const selectEntitiesPage = createSelector(selectPageEntitiesList, selectEntitiesPageInfo, 
+    // props look unsued but they are pass to the selectPageEntities
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    (entities, pageInfo, props = { page: pageInfo.pageIndex }) => (Object.assign({ entities }, pageInfo)));
+    const selectEntitiesPagedRequest = createSelector(selectPagination, (pagination) => ({
+        startIndex: pagination.pageSize * pagination.requestPage,
+        size: pagination.pageSize * pagination.pagesToCache,
+        page: pagination.requestPage,
+    }));
+    const isLoadingEntitiesPage = createSelector(isEntitiesLoading, selectPagination, (isLoading, pagination) => isLoading && pagination.requestPage === pagination.currentPage);
+    return {
+        selectPageEntitiesList,
+        isEntitiesPageInCache,
+        selectEntitiesPage,
+        selectEntitiesPagedRequest,
+        selectEntitiesPageInfo,
+        isLoadingEntitiesPage,
+    };
+}
+
+function createPaginationTraitActions(actionsGroupKey, entitiesName) {
+    const actions = {
+        loadEntitiesPage: createAction(`${actionsGroupKey} Load ${entitiesName} Page`, ({ index, forceLoad }) => ({
+            index,
+            forceLoad,
+        })),
+        loadEntitiesPageSuccess: createAction(`${actionsGroupKey} Load  ${entitiesName}
+          Page Success`),
+        loadEntitiesPageFail: createAction(`${actionsGroupKey} Load ${entitiesName} Page Fail`),
+        loadEntitiesPreviousPage: createAction(`${actionsGroupKey} Load Previous ${entitiesName} Page`),
+        loadEntitiesNextPage: createAction(`${actionsGroupKey} Load Next ${entitiesName} Page`),
+        loadEntitiesFirstPage: createAction(`${actionsGroupKey} Load First ${entitiesName} Page`, (forceLoad) => ({ forceLoad })),
+        loadEntitiesLastPage: createAction(`${actionsGroupKey} Load Last ${entitiesName} Page`),
+        clearEntitiesPagesCache: createAction(`${actionsGroupKey} Clear ${entitiesName} Cache`),
+        setEntitiesRequestPage: createAction(`${actionsGroupKey} Set ${entitiesName} Request Page`, props()),
+    };
+    return actions;
+}
+
+function createPaginationInitialState(previousInitialState, allConfigs) {
+    const { currentPage, pageSize, cacheType, pagesToCache } = allConfigs.pagination;
+    return Object.assign(Object.assign({}, previousInitialState), { pagination: {
+            pageSize,
+            currentPage,
+            requestPage: currentPage,
+            pagesToCache,
+            cache: {
+                type: cacheType,
+                start: 0,
+                end: 0,
+            },
+        } });
+}
+function createPaginationTraitReducer(initialState, allActions, allSelectors, allMutators, allConfigs) {
+    var _a;
+    function addToCacheTotal(state, add) {
+        var _a;
+        return Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { total: ((_a = state.pagination.total) !== null && _a !== void 0 ? _a : 0) + add }) });
+    }
+    function clearPagesCache(state) {
+        return Object.assign(Object.assign({}, state), { entities: {}, ids: [], pagination: Object.assign(Object.assign({}, state.pagination), { currentPage: 0, total: 0, cache: Object.assign(Object.assign({}, state.pagination.cache), { start: 0, end: 0 }) }) });
+    }
+    function recalculateTotal(state) {
+        const total = allSelectors.selectEntitiesTotal(state);
+        return Object.assign(Object.assign({}, state), { status: 'success', pagination: Object.assign(Object.assign({}, state.pagination), { currentPage: 0, total, cache: Object.assign(Object.assign({}, state.pagination.cache), { start: 0, end: total }) }) });
+    }
+    const filterRemote = !((_a = allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.filter) === null || _a === void 0 ? void 0 : _a.filterFn);
+    return createReducer(initialState, on(allActions.loadEntitiesPage, (state, { index }) => (Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { currentPage: index, requestPage: index }), status: 'loading' }))), on(allActions.setEntitiesRequestPage, (state, { index }) => (Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { requestPage: index }), status: 'loading' }))), on(allActions.loadEntitiesPageSuccess, (state) => (Object.assign(Object.assign({}, state), { status: 'success' }))), on(allActions.loadEntitiesPageFail, (state) => (Object.assign(Object.assign({}, state), { status: 'fail' }))), on(allActions.clearEntitiesPagesCache, (state) => clearPagesCache(state)), on(allActions.loadEntitiesSuccess, (state, { entities, total }) => allMutators.mergePaginatedEntities(entities, total, Object.assign(Object.assign({}, state), { status: 'success' }))), ...insertIf(allActions.addEntities, () => on(allActions.addEntities, (state, { entities }) => addToCacheTotal(state, entities.length))), ...insertIf(allActions.removeEntities, () => on(allActions.removeEntities, (state, { keys }) => addToCacheTotal(state, -keys.length))), ...insertIf(filterRemote && allActions.filterEntities, () => on(allActions.filterEntities, (state) => recalculateTotal(state))), ...insertIf(allActions.removeAllEntities, () => on(allActions.removeAllEntities, (state) => clearPagesCache(state))));
+}
+
+function createPaginationTraitEffects(allActions, allSelectors) {
+    class PaginationEffect extends TraitEffect {
+        constructor() {
+            super(...arguments);
+            this.loadPage$ = createEffect(() => {
+                return this.actions$.pipe(ofType(allActions.loadEntitiesPage), concatLatestFrom(() => this.store.select(allSelectors.isEntitiesPageInCache)), map(([{ forceLoad }, isInCache]) => !forceLoad && isInCache
+                    ? allActions.loadEntitiesPageSuccess()
+                    : allActions.loadEntities()));
+            });
+            this.preloadNextPage$ = createEffect(() => {
+                return this.actions$.pipe(ofType(allActions.loadEntitiesPageSuccess), concatMapTo(this.store.select(allSelectors.selectEntitiesPageInfo).pipe(first())), filter((pageInfo) => !!pageInfo.total &&
+                    pageInfo.hasNext &&
+                    pageInfo.cacheType !== 'full'), concatMap((pageInfo) => this.store
+                    .select(allSelectors.isEntitiesPageInCache, {
+                    page: pageInfo.pageIndex + 1,
+                })
+                    .pipe(first(), map((isInCache) => (!isInCache && pageInfo) || undefined))), filter((pageInfo) => !!pageInfo), concatMap((pageInfo) => [
+                    allActions.setEntitiesRequestPage({ index: pageInfo.pageIndex + 1 }),
+                    allActions.loadEntities(),
+                ]));
+            });
+            this.loadFirstPage$ = createEffect(() => {
+                return this.actions$.pipe(ofType(allActions.loadEntitiesFirstPage), map(() => allActions.loadEntitiesPage({ index: 0 })));
+            });
+            this.loadPreviousPage$ = createEffect(() => {
+                return this.actions$.pipe(ofType(allActions.loadEntitiesPreviousPage), concatMapTo(this.store.select(allSelectors.selectEntitiesPageInfo).pipe(first())), map((page) => page.hasPrevious
+                    ? allActions.loadEntitiesPage({ index: page.pageIndex - 1 })
+                    : allActions.loadEntitiesPageFail()));
+            });
+            this.loadNextPage$ = createEffect(() => {
+                return this.actions$.pipe(ofType(allActions.loadEntitiesNextPage), concatMapTo(this.store.select(allSelectors.selectEntitiesPageInfo).pipe(first())), map((page) => page.hasNext
+                    ? allActions.loadEntitiesPage({ index: page.pageIndex + 1 })
+                    : allActions.loadEntitiesPageFail()));
+            });
+            this.loadLastPage$ = createEffect(() => {
+                return this.actions$.pipe(ofType(allActions.loadEntitiesLastPage), concatMapTo(this.store.select(allSelectors.selectEntitiesPageInfo).pipe(first())), map((page) => page.hasNext && page.pagesCount
+                    ? allActions.loadEntitiesPage({ index: page.pagesCount - 1 })
+                    : allActions.loadEntitiesPageFail()));
+            });
+        }
+    }
+    PaginationEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: PaginationEffect, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    PaginationEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: PaginationEffect });
+    i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: PaginationEffect, decorators: [{
+                type: Injectable
+            }] });
+    return [PaginationEffect];
+}
+
+function createPaginationTraitMutators(allSelectors, allConfigs) {
+    const adapter = allConfigs.loadEntities.adapter;
+    function mergePaginatedEntities(entities, total = undefined, state) {
+        const cacheType = state.pagination.cache.type;
+        switch (cacheType) {
+            case 'full':
+                return adapter.setAll(entities, Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { total: entities.length, cache: Object.assign(Object.assign({}, state.pagination.cache), { start: 0, end: entities.length }) }) }));
+            case 'partial': {
+                const isPreloadNextPages = state.pagination.currentPage + 1 === state.pagination.requestPage;
+                const start = state.pagination.currentPage * state.pagination.pageSize;
+                const newEntities = isPreloadNextPages
+                    ? [...allSelectors.selectPageEntitiesList(state), ...entities]
+                    : entities;
+                return adapter.setAll(newEntities, Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { total, cache: Object.assign(Object.assign({}, state.pagination.cache), { start, end: start + entities.length }) }) }));
+            }
+            case 'grow':
+                return adapter.addMany(entities, Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { total, cache: Object.assign(Object.assign({}, state.pagination.cache), { end: state.ids.length + entities.length }) }) }));
+        }
+        return state;
+    }
+    return { mergePaginatedEntities };
+}
+
+/**
+ * Generates ngrx code to paginate an list of entities, this has 3 cache `cacheType`
+ * - 'full': The full result is cache in memory and split in pages to render, useful
+ * for small result but not so small that requires been render in pages
+ * - 'partial': Backend returns partial results because is are to big, this has a cache a few pages forward
+ * to avoid calling the backend on each page, the cache is clean when a new loadEntities is required
+ * - 'grow': Similar to partial that the backend returns partial result, but in this case the cache grows,
+ * after each loadEntities the cache is appended to the previous cache, this mode is ideal for infinite scrolls,
+ * where you will only call loadNextPage.
+ * To make the pagination experience smoother the loadEntities to get new pages is done when the current page is change to
+ * the last cached page.
+ * @param config
+ * @param config.cacheType - Default to 'full', change the cache mode
+ * @param config.pageSize - Default to 20, number of entities on  each page
+ * @param config.currentPage - Default to 0, starting page
+ * @param config.pagesToCache - Default to 3, used in partial and grow cache mode, is the number of
+ * extra pages kept in cache to avoid calling the backend on each page
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,SingleSelectionState{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addEntitiesPaginationTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions and selectors, plus the ones generated by other traits
+ * traits.actions.loadTodosPage({index})
+ * traits.actions.loadTodosPageSuccess()
+ * traits.actions.loadTodosPageFail()
+ * traits.actions.loadTodosNextPage()
+ * traits.actions.loadTodosPreviousPage()
+ * traits.actions.loadTodosFirstPage()
+ * traits.actions.loadTodosLastPage()
+ * traits.actions.clearTodosPagesCache()
+ *
+ * // page param is optional and defaults to current page
+ * traits.selectors.isTodosPageInCache({page})
+ * traits.selectors.selectPageTodosList({page})
+ * traits.selectors.isLoadingTodosPage({page})
+ * // prefer isLoadingTodosPage over isLoadingTodos which will return true even
+ * // if the page loading is not the current one
+ * traits.selectors.selectTodosPage({page})
+ * traits.selectors.selectTodosPagedRequest()// use in effects to get paging parameter
+ * traits.selectors.selectTodosPageInfo()
+ */
+function addEntitiesPaginationTrait({ cacheType = 'full', pageSize = 20, currentPage = 0, pagesToCache = 3, } = {}) {
+    return createTraitFactory({
+        key: entitiesPaginationTraitKey,
+        depends: [loadEntitiesTraitKey],
+        config: {
+            cacheType,
+            pageSize,
+            currentPage,
+            pagesToCache,
+        },
+        actions: ({ actionsGroupKey, entitiesName }) => createPaginationTraitActions(actionsGroupKey, entitiesName),
+        selectors: ({ previousSelectors, allConfigs, }) => createPaginationTraitSelectors(previousSelectors, allConfigs),
+        mutators: ({ allSelectors, allConfigs }) => createPaginationTraitMutators(allSelectors, allConfigs),
+        initialState: ({ previousInitialState, allConfigs, }) => createPaginationInitialState(previousInitialState, allConfigs),
+        reducer: ({ initialState, allActions, allSelectors, allMutators, allConfigs, }) => createPaginationTraitReducer(initialState, allActions, allSelectors, allMutators, allConfigs),
+        effects: ({ allActions, allSelectors }) => createPaginationTraitEffects(allActions, allSelectors),
+    });
+}
+
+function createSelectEntitiesTraitActions(actionsGroupKey, entitiesName) {
+    return {
+        selectEntities: createAction(`${actionsGroupKey} Select ${entitiesName}`, props()),
+        deselectEntities: createAction(`${actionsGroupKey} Deselect ${entitiesName}`, props()),
+        toggleSelectEntities: createAction(`${actionsGroupKey} Toggle Select ${entitiesName}`, props()),
+        toggleSelectAllEntities: createAction(`${actionsGroupKey} Toggle Select All ${entitiesName}`),
+        clearEntitiesSelection: createAction(`${actionsGroupKey} Clear ${entitiesName} Selection`),
+    };
+}
+
+function deselectEntities(id, state) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const _a = state.selectedIds, _b = id, _value = _a[_b], selectedIds = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+    return Object.assign(Object.assign({}, state), { selectedIds: selectedIds });
+}
+function selectEntities(id, state) {
+    return Object.assign(Object.assign({}, state), { selectedIds: Object.assign(Object.assign({}, state.selectedIds), { [id]: true }) });
+}
+function toggleSelectEntities(id, state) {
+    const selected = state.selectedIds[id];
+    if (selected) {
+        return deselectEntities(id, state);
+    }
+    else {
+        return selectEntities(id, state);
+    }
+}
+function clearEntitiesSelection(state) {
+    return Object.assign(Object.assign({}, state), { selectedIds: {} });
+}
+function selectTotalSelectedEntities(state) {
+    return Object.keys(state.selectedIds).length;
+}
+
+function createSelectEntitiesTraitSelectors(previousSelectors) {
+    const { selectEntitiesMap, selectEntitiesTotal } = previousSelectors;
+    function selectEntitiesIdsSelectedMap(state) {
+        return state.selectedIds;
+    }
+    const selectEntitiesIdsSelectedList = createSelector(selectEntitiesIdsSelectedMap, (ids) => Object.keys(ids));
+    const selectEntitiesSelectedMap = createSelector(selectEntitiesIdsSelectedList, selectEntitiesMap, (selectedIds, entities) => selectedIds.reduce((acum, id) => {
+        acum[id] = entities[id];
+        return acum;
+    }, {}));
+    const selectEntitiesSelectedList = createSelector(selectEntitiesIdsSelectedList, selectEntitiesMap, (selectedIds, entities) => selectedIds.map((id) => entities[id]));
+    const isAllEntitiesSelected = createSelector((state) => selectEntitiesTotal(state), selectTotalSelectedEntities, (total, totalSelected) => totalSelected > 0 && totalSelected === total
+        ? 'all'
+        : totalSelected === 0
+            ? 'none'
+            : 'some');
+    return {
+        selectEntitiesIdsSelectedMap,
+        selectEntitiesIdsSelectedList,
+        selectEntitiesSelectedMap,
+        selectEntitiesSelectedList,
+        selectTotalSelectedEntities,
+        isAllEntitiesSelected,
+    };
+}
+
+function createSelectEntitiesInitialState(previousInitialState) {
+    return Object.assign(Object.assign({}, previousInitialState), { selectedIds: {} });
+}
+function createSelectEntitiesTraitReducer(initialState, allActions, allMutators, allConfigs) {
+    var _a, _b;
+    const { adapter } = allConfigs.loadEntities;
+    const sortRemote = (_a = allConfigs.sort) === null || _a === void 0 ? void 0 : _a.remote;
+    const paginationCacheType = (_b = allConfigs.pagination) === null || _b === void 0 ? void 0 : _b.cacheType;
+    function updateSelectedIdsChanged(state, updates) {
+        const changedIds = updates.reduce((acc, updated) => {
+            const id = adapter.selectId(updated.changes);
+            if (id && id !== updated.id && state.selectedIds[updated.id] != null) {
+                acc.push(updated);
+                return acc;
+            }
+            return acc;
+        }, []);
+        if (changedIds.length) {
+            const selectedIds = Object.assign({}, state.selectedIds);
+            changedIds.forEach((updated) => {
+                const id = adapter.selectId(updated.changes);
+                const value = selectedIds[updated.id];
+                delete selectedIds[updated.id];
+                selectedIds[id] = value;
+            });
+            return Object.assign(Object.assign({}, state), { selectedIds });
+        }
+        return state;
+    }
+    return createReducer(initialState, on(allActions.selectEntities, (state, { id }) => allMutators.selectEntities(id, state)), on(allActions.deselectEntities, (state, { id }) => allMutators.deselectEntities(id, state)), on(allActions.toggleSelectEntities, (state, { id }) => allMutators.toggleSelectEntities(id, state)), on(allActions.toggleSelectAllEntities, (state) => allMutators.toggleSelectAllEntities(state)), ...insertIf(allActions.removeEntities, () => on(allActions.removeEntities, (state, { keys }) => {
+        const selectedIds = Object.assign({}, state.selectedIds);
+        keys.forEach((v) => {
+            delete selectedIds[v];
+        });
+        return Object.assign(Object.assign({}, state), { selectedIds });
+    })), ...insertIf(allActions.updateEntities, () => on(allActions.updateEntities, (state, { updates }) => updateSelectedIdsChanged(state, updates))), on(allActions.clearEntitiesSelection, (state) => allMutators.clearEntitiesSelection(state)), ...insertIf(allActions.removeAllEntities, () => on(allActions.removeAllEntities, (state) => allMutators.clearEntitiesSelection(state))), ...insertIf(sortRemote, () => on(allActions.sortEntities, (state) => allMutators.clearEntitiesSelection(state))), ...insertIf(allActions.filterEntities, () => on(allActions.filterEntities, (state) => allMutators.clearEntitiesSelection(state))), ...insertIf(!allActions.loadEntitiesPageSuccess, () => on(allActions.loadEntitiesSuccess, (state) => allMutators.clearEntitiesSelection(state))), ...insertIf(!!allActions.loadEntitiesPageSuccess && paginationCacheType === 'partial', () => on(allActions.loadEntitiesPageSuccess, (state) => allMutators.clearEntitiesSelection(state))));
+}
+
+function createSelectEntitiesTraitMutators({ isAllEntitiesSelected, }) {
+    function toggleSelectAllEntities(state) {
+        const allSelected = isAllEntitiesSelected(state);
+        if (allSelected === 'all') {
+            return Object.assign(Object.assign({}, state), { selectedIds: {} });
+        }
+        else {
+            return Object.assign(Object.assign({}, state), { selectedIds: toMap(state.ids) });
+        }
+    }
+    return {
+        selectEntities,
+        deselectEntities,
+        toggleSelectEntities,
+        toggleSelectAllEntities,
+        clearEntitiesSelection,
+    };
+}
+
+/**
+ * Generates ngrx code to add multi selection to a list
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,MultipleSelectionState{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addSelectEntitiesTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions and selectors, plus the ones generated by other traits
+ * traits.actions.selectTodos({id})
+ * traits.actions.deselectTodos({id})
+ * traits.actions.toggleSectTodos({id})
+ * traits.actions.toggleSelectAllTodos()
+ * traits.actions.clearTodosSelection()
+ *
+ * traits.selectors.isAllTodosSelected()
+ * traits.selectors.selectTodosIdsSelectedMap()
+ * traits.selectors.selectTodosIdsSelectedList()
+ * traits.selectors.selectTodosSelectedMap()
+ * traits.selectors.selectTodosSelectedList()
+ * traits.selectors.selectTotalSelectedTodos()
+ */
+function addSelectEntitiesTrait() {
+    return createTraitFactory({
+        key: 'SelectEntities',
+        depends: [loadEntitiesTraitKey],
+        actions: ({ actionsGroupKey, entitiesName }) => createSelectEntitiesTraitActions(actionsGroupKey, entitiesName),
+        selectors: ({ previousSelectors }) => createSelectEntitiesTraitSelectors(previousSelectors),
+        initialState: ({ previousInitialState }) => createSelectEntitiesInitialState(previousInitialState),
+        mutators: ({ allSelectors }) => createSelectEntitiesTraitMutators(allSelectors),
+        reducer: ({ initialState, allActions, allMutators, allConfigs }) => createSelectEntitiesTraitReducer(initialState, allActions, allMutators, allConfigs),
+    });
+}
+
+function createSelectEntityTraitActions(actionsGroupKey, entityName) {
+    return {
+        selectEntity: createAction(`${actionsGroupKey} Select ${entityName}`, props()),
+        deselectEntity: createAction(`${actionsGroupKey} Deselect ${entityName}`),
+        toggleSelectEntity: createAction(`${actionsGroupKey} Toggle Select ${entityName}`, props()),
+    };
+}
+
+function createSelectEntityTraitSelectors() {
+    function selectEntityIdSelected(state) {
+        return state.selectedId;
+    }
+    function selectEntitySelected(state) {
+        return (state.selectedId && state.entities[state.selectedId]) || undefined;
+    }
+    return {
+        selectEntityIdSelected,
+        selectEntitySelected,
+    };
+}
+
+function createSelectEntityInitialState(previousInitialState, allConfigs) {
+    var _a;
+    const selectedId = (_a = allConfigs.singleSelection) === null || _a === void 0 ? void 0 : _a.selectedId;
+    return Object.assign(Object.assign({}, previousInitialState), { selectedId });
+}
+function createSelectEntityTraitReducer(initialState, allActions, allMutators, allConfigs) {
+    var _a, _b;
+    const { adapter } = allConfigs.loadEntities;
+    const sortRemote = (_a = allConfigs.sort) === null || _a === void 0 ? void 0 : _a.remote;
+    const paginationCacheType = (_b = allConfigs.pagination) === null || _b === void 0 ? void 0 : _b.cacheType;
+    return createReducer(initialState, on(allActions.selectEntity, (state, { id }) => allMutators.selectEntity(id, state)), on(allActions.deselectEntity, (state) => allMutators.deselectEntity(state)), on(allActions.toggleSelectEntity, (state, { id }) => allMutators.toggleSelectEntity(id, state)), ...insertIf(allActions.removeAllEntities, () => on(allActions.removeAllEntities, (state) => allMutators.deselectEntity(state))), ...insertIf(sortRemote, () => on(allActions.sortEntities, (state) => allMutators.deselectEntity(state))), ...insertIf(allActions.filterEntities, () => on(allActions.filterEntities, (state) => allMutators.deselectEntity(state))), ...insertIf(!allActions.loadEntitiesPageSuccess, () => on(allActions.loadEntitiesSuccess, (state) => allMutators.deselectEntity(state))), ...insertIf(!!allActions.loadEntitiesPageSuccess && paginationCacheType === 'partial', () => on(allActions.loadEntitiesPageSuccess, (state) => allMutators.deselectEntity(state))), ...insertIf(allActions.removeEntities, () => on(allActions.removeEntities, (state, { keys }) => {
+        const shouldDeselect = keys.some((v) => v === state.selectedId);
+        return shouldDeselect
+            ? Object.assign(Object.assign({}, state), { selectedId: undefined }) : state;
+    })), ...insertIf(allActions.updateEntities, () => on(allActions.updateEntities, (state, { updates }) => {
+        const change = updates.find((updated) => {
+            const id = adapter.selectId(updated.changes);
+            return id && id !== updated.id && state.selectedId === updated.id;
+        });
+        return change
+            ? Object.assign(Object.assign({}, state), { selectedId: adapter.selectId(change.changes) }) : state;
+    })));
+}
+
+function createSelectEntityTraitMutators() {
+    function selectEntity(id, state) {
+        return Object.assign(Object.assign({}, state), { selectedId: id });
+    }
+    function deselectEntity(state) {
+        return Object.assign(Object.assign({}, state), { selectedId: undefined });
+    }
+    function toggleSelectEntity(id, state) {
+        return Object.assign(Object.assign({}, state), { selectedId: state.selectedId === id ? undefined : id });
+    }
+    return {
+        selectEntity,
+        deselectEntity,
+        toggleSelectEntity,
+    };
+}
+
+/**
+ * Generates ngrx code to add single selection to a list
+ * @param config
+ * @param config.selectedId - Default selected id
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,SelectEntityState{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addSelectEntityTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions and selectors, plus the ones generated by other traits
+ * traits.actions.selectTodo({id})
+ * traits.actions.deselectTodo()
+ * traits.actions.toggleSelectTodo({id})
+ *
+ * traits.selectors.selectTodoIdSelected()
+ * traits.selectors.selectTodoSelected()
+ */
+function addSelectEntityTrait(config) {
+    return createTraitFactory({
+        key: 'singleSelection',
+        depends: [loadEntitiesTraitKey],
+        config,
+        actions: ({ actionsGroupKey, entityName }) => createSelectEntityTraitActions(actionsGroupKey, entityName),
+        selectors: () => createSelectEntityTraitSelectors(),
+        mutators: () => createSelectEntityTraitMutators(),
+        initialState: ({ previousInitialState, allConfigs, }) => createSelectEntityInitialState(previousInitialState, allConfigs),
+        reducer: ({ initialState, allActions, allMutators, allConfigs }) => createSelectEntityTraitReducer(initialState, allActions, allMutators, allConfigs),
+    });
+}
+
+const selectEntityTraitKey = 'singleSelection';
+
+var ChangeType;
+(function (ChangeType) {
+    ChangeType["CREATED"] = "c";
+    ChangeType["UPDATED"] = "u";
+    ChangeType["DELETED"] = "d";
+})(ChangeType || (ChangeType = {}));
+const crudEntitiesTraitKey = 'crud';
+
+function createCrudTraitActions(actionsGroupKey, entitiesName) {
+    return {
+        addEntities: createAction(`${actionsGroupKey} Add ${entitiesName}`, (...entities) => ({
+            entities,
+        })),
+        removeEntities: createAction(`${actionsGroupKey} Remove ${entitiesName}`, (...keys) => ({
+            keys,
+        })),
+        updateEntities: createAction(`${actionsGroupKey} Update ${entitiesName}`, (...updates) => ({
+            updates,
+        })),
+        upsertEntities: createAction(`${actionsGroupKey} Upsert ${entitiesName}`, (...entities) => ({
+            entities,
+        })),
+        removeAllEntities: createAction(`${actionsGroupKey} Remove All ${entitiesName}`, (predicate) => ({ predicate })),
+        clearEntitiesChanges: createAction(`${actionsGroupKey} Clear  ${entitiesName} Changes`),
+    };
+}
+
+function createCrudTraitSelectors(previousSelectors) {
+    function selectChanges(state) {
+        return state.changes;
+    }
+    function selectFilteredChanges(state) {
+        const cache = {};
+        return state.changes.reduce((acc, value) => {
+            const changes = cache[value.id];
+            if (!changes) {
+                cache[value.id] = [value.changeType];
+                acc.push(value);
+                return acc;
+            }
+            if (value.changeType === ChangeType.UPDATED) {
+                return acc;
+            }
+            if (value.changeType === ChangeType.DELETED &&
+                changes.includes(ChangeType.CREATED)) {
+                delete cache[value.id];
+                return acc.filter((v) => v.id !== value.id);
+            }
+            if (value.changeType === ChangeType.DELETED) {
+                delete cache[value.id];
+                const newAcc = acc.filter((v) => v.id !== value.id);
+                newAcc.push(value);
+                return newAcc;
+            }
+            return acc;
+        }, []);
+    }
+    const { selectEntitiesMap } = previousSelectors;
+    const selectEntitiesChangesList = createSelector((state) => selectEntitiesMap(state), selectChanges, (entities, changed, { type }) => {
+        if (type)
+            return changed
+                .filter((c) => c.changeType === type)
+                .map((change) => {
+                var _a;
+                return ({
+                    changeType: change.changeType,
+                    entity: (_a = entities[change.id]) !== null && _a !== void 0 ? _a : {
+                        id: change.id,
+                    },
+                });
+            });
+        const map = changed.map((change) => {
+            var _a;
+            return ({
+                changeType: change.changeType,
+                entity: (_a = entities[change.id]) !== null && _a !== void 0 ? _a : {
+                    id: change.id,
+                },
+            });
+        });
+        return map;
+    });
+    const selectFilteredEntitiesChangesList = createSelector(selectFilteredChanges, (state) => selectEntitiesMap(state), (changes, entities) => changes.map((c) => {
+        var _a;
+        return {
+            entity: (_a = entities[c.id]) !== null && _a !== void 0 ? _a : { id: c.id },
+            changeType: c.changeType,
+        };
+    }));
+    return {
+        selectEntitiesChangesList,
+        selectFilteredEntitiesChangesList,
+    };
+}
+
+function createCrudInitialState(previousInitialState) {
+    return Object.assign(Object.assign({}, previousInitialState), { changes: [] });
+}
+function createCrudTraitReducer(initialState, allActions, allMutators, allConfigs) {
+    var _a, _b, _c;
+    const sortRemote = (_a = allConfigs.sort) === null || _a === void 0 ? void 0 : _a.remote;
+    const filterRemote = allConfigs.filter && !((_b = allConfigs.filter) === null || _b === void 0 ? void 0 : _b.filterFn);
+    const paginationCacheType = (_c = allConfigs.pagination) === null || _c === void 0 ? void 0 : _c.cacheType;
+    return createReducer(initialState, on(allActions.addEntities, (state, { entities }) => allMutators.addEntities(entities, state)), on(allActions.updateEntities, (state, { updates }) => allMutators.updateEntities(updates, state)), on(allActions.upsertEntities, (state, { entities }) => allMutators.upsertEntities(entities, state)), on(allActions.removeEntities, (state, { keys }) => allMutators.removeEntities(keys, state)), on(allActions.removeAllEntities, (state, { predicate }) => predicate
+        ? allMutators.removeEntities(predicate, state)
+        : allMutators.removeAllEntities(state)), on(allActions.clearEntitiesChanges, (state) => allMutators.clearEntitiesChanges(state)), ...insertIf(sortRemote, () => on(allActions.sortEntities, (state) => allMutators.clearEntitiesChanges(state))), ...insertIf(filterRemote, () => on(allActions.filterEntities, (state) => allMutators.clearEntitiesChanges(state))), ...insertIf(!allActions.loadEntitiesPageSuccess, () => on(allActions.loadEntitiesSuccess, (state) => allMutators.clearEntitiesChanges(state))), ...insertIf(!!allActions.loadEntitiesPageSuccess && paginationCacheType === 'partial', () => on(allActions.loadEntitiesPageSuccess, (state) => allMutators.clearEntitiesChanges(state))));
+}
+
+function createCrudTraitMutators(allConfigs) {
+    const { storeChanges } = allConfigs.crud || {};
+    const adapter = allConfigs.loadEntities.adapter;
+    function generateChangeEntry(entity, changeType, customId) {
+        return {
+            id: customId !== null && customId !== void 0 ? customId : adapter.selectId(entity),
+            changeType,
+            entityChanges: (storeChanges && entity) || undefined,
+        };
+    }
+    function addEntities(entities, state, addFirst = false) {
+        const changes = [
+            ...state.changes,
+            ...entities.map((entity) => generateChangeEntry(entity, ChangeType.CREATED)),
+        ];
+        if (!addFirst)
+            return adapter.addMany(entities, Object.assign(Object.assign({}, state), { changes }));
+        const newIds = entities.map((e) => adapter.selectId(e));
+        const newEntities = Object.assign({}, state.entities);
+        entities.forEach((e) => {
+            const id = adapter.selectId(e);
+            newEntities[id] = e;
+        });
+        return Object.assign(Object.assign({}, state), { ids: [...newIds, ...state.ids], entities: newEntities, changes });
+    }
+    function upsertEntities(entities, state) {
+        const oldChanges = [...state.changes];
+        const existingIds = adapter.getSelectors().selectIds(state);
+        const [additions, updates] = entities.reduce(([a, u], entity) => existingIds.indexOf(adapter.selectId(entity)) !== -1
+            ? [a, [...u, entity]]
+            : [[...a, entity], u], [new Array(), new Array()]);
+        return adapter.upsertMany(entities, Object.assign(Object.assign({}, state), { changes: [
+                ...oldChanges,
+                ...additions.map((entity) => generateChangeEntry(entity, ChangeType.CREATED)),
+                ...updates.map((entity) => generateChangeEntry(entity, ChangeType.UPDATED)),
+            ] }));
+    }
+    function removeEntities(keysOrPredicate, state) {
+        if (typeof keysOrPredicate === 'function') {
+            return adapter.removeMany(keysOrPredicate, Object.assign(Object.assign({}, state), { changes: [
+                    ...state.changes,
+                    ...state.ids.map((id) => ({
+                        id,
+                        changeType: ChangeType.DELETED,
+                    })),
+                ] }));
+        }
+        return adapter.removeMany(keysOrPredicate, Object.assign(Object.assign({}, state), { changes: [
+                ...state.changes,
+                ...keysOrPredicate.map((key) => ({
+                    id: key,
+                    changeType: ChangeType.DELETED,
+                })),
+            ] }));
+    }
+    function removeAllEntities(state) {
+        return adapter.removeAll(Object.assign(Object.assign({}, state), { changes: [
+                ...state.changes,
+                ...state.ids.map((id) => ({
+                    id,
+                    changeType: ChangeType.DELETED,
+                })),
+            ] }));
+    }
+    function clearEntitiesChanges(state) {
+        return Object.assign(Object.assign({}, state), { changes: [] });
+    }
+    function updateEntities(updates, state) {
+        const oldChanges = [...state.changes];
+        updates.forEach((updated) => {
+            const id = adapter.selectId(updated.changes);
+            if (id && id !== updated.id) {
+                // if the id changes update the id of pold changes
+                const index = oldChanges.findIndex((v) => v.id === updated.id);
+                const oldChange = oldChanges[index];
+                oldChanges[index] = Object.assign(Object.assign({}, oldChange), { id });
+            }
+        });
+        return adapter.updateMany(updates, Object.assign(Object.assign({}, state), { changes: [
+                ...oldChanges,
+                ...updates.map((updated) => {
+                    var _a;
+                    return ({
+                        id: (_a = adapter.selectId(updated.changes)) !== null && _a !== void 0 ? _a : updated.id,
+                        changeType: ChangeType.UPDATED,
+                        entityChanges: (storeChanges && updated.changes) || undefined,
+                    });
+                }),
+            ] }));
+    }
+    return {
+        addEntities,
+        removeEntities,
+        updateEntities,
+        removeAllEntities,
+        clearEntitiesChanges,
+        upsertEntities,
+    };
+}
+
+/**
+ * Generates ngrx code to add, remove update, upsert entities on a list, it also
+ * tracks the changes made, helpful for implementing batch updates. The `storeChanges` (false by default),
+ * will store for add and update the changed entity props in the property `entityChanges` of the `Change` object.
+ * @param config
+ * @param config.storeChanges - Will store the changes made, default fals
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>, CrudState<Todo>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addCrudEntitiesTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions and selectors, plus the ones generated by other traits
+ * traits.actions.addTodos(entity1,entity2...)
+ * traits.actions.updateTodos({id: id1, changes:{prop1}},{id: id2, changes:{prop2}} ...)
+ * traits.actions.upsertTodos(entity1,entity2...)
+ * traits.actions.removeAllTodos()
+ * traits.actions.clearTodosChanges()
+ *
+ * traits.selectors.selectTodosChangesList()
+ * traits.selectors.selectFilteredTodosChangesList()
+ * traits.selectors.selectAllFilteredChanges()
+ */
+function addCrudEntitiesTrait({ storeChanges = false, } = {}) {
+    return createTraitFactory({
+        key: crudEntitiesTraitKey,
+        depends: [loadEntitiesTraitKey],
+        config: { storeChanges },
+        actions: ({ actionsGroupKey, entitiesName }) => createCrudTraitActions(actionsGroupKey, entitiesName),
+        selectors: ({ previousSelectors }) => createCrudTraitSelectors(previousSelectors),
+        mutators: ({ allConfigs }) => createCrudTraitMutators(allConfigs),
+        initialState: ({ previousInitialState }) => createCrudInitialState(previousInitialState),
+        reducer: ({ initialState, allActions, allMutators, allConfigs }) => createCrudTraitReducer(initialState, allActions, allMutators, allConfigs),
+    });
+}
+
+const sortTraitKey = 'sort';
+
+const MAX_SAFE_INTEGER = 9007199254740991;
+function _isNumberValue(value) {
+    // parseFloat(value) handles most of the cases we're interested in (it treats null, empty string,
+    // and other non-number values as NaN, where Number just uses 0) but it considers the string
+    // '123hello' to be a valid number. Therefore we also check if Number(value) is NaN.
+    return !isNaN(parseFloat(value)) && !isNaN(Number(value));
+}
+function sortingDataAccessor(data, sortHeaderId) {
+    const value = data[sortHeaderId];
+    if (_isNumberValue(value)) {
+        const numberValue = Number(value);
+        // Numbers beyond `MAX_SAFE_INTEGER` can't be compared reliably so we
+        // leave them as strings. For more info: https://goo.gl/y5vbSg
+        return numberValue < MAX_SAFE_INTEGER ? numberValue : value;
+    }
+    return value;
+}
+/**
+ * Gets a sorted copy of the data array based on the state of the Sort.
+ * @param data The array of data that should be sorted.
+ * @param sort The connected MatSort that holds the current sort state.
+ */
+function sortData(data, sort) {
+    const active = sort.active;
+    const direction = sort.direction;
+    if (!active || direction === '') {
+        return data;
+    }
+    return data.sort((a, b) => {
+        const valueA = sortingDataAccessor(a, active);
+        const valueB = sortingDataAccessor(b, active);
+        // If both valueA and valueB exist (truthy), then compare the two. Otherwise, check if
+        // one value exists while the other doesn't. In this case, existing value should come last.
+        // This avoids inconsistent results when comparing values to undefined/null.
+        // If neither value exists, return 0 (equal).
+        let comparatorResult = 0;
+        if (valueA != null && valueB != null) {
+            // Check if one value is greater than the other; if equal, comparatorResult should remain 0.
+            if (typeof valueA === 'string' || typeof valueB === 'string') {
+                // if either values are a string, then force both to be strings before localCompare
+                comparatorResult = valueA.toString().localeCompare(valueB.toString());
+            }
+            else {
+                if (valueA > valueB) {
+                    comparatorResult = 1;
+                }
+                else if (valueA < valueB) {
+                    comparatorResult = -1;
+                }
+            }
+        }
+        else if (valueA != null) {
+            comparatorResult = 1;
+        }
+        else if (valueB != null) {
+            comparatorResult = -1;
+        }
+        return comparatorResult * (direction === 'asc' ? 1 : -1);
+    });
+}
+
+function createSortTraitMutators({ selectEntitiesList }, allConfigs) {
+    function sortEntities({ active, direction }, state) {
+        const { adapter } = allConfigs.loadEntities;
+        const entities = selectEntitiesList(state);
+        const sortedIds = sortData(entities, { active, direction }).map((v) => adapter.selectId(v));
+        return Object.assign(Object.assign({}, state), { ids: sortedIds, sort: Object.assign(Object.assign({}, state.sort), { current: { active, direction } }) });
+    }
+    return {
+        sortEntities,
+    };
+}
+
+function createSortInitialState(previousInitialState, allConfigs) {
+    const { defaultSort } = allConfigs.sort;
+    return Object.assign(Object.assign({}, previousInitialState), { sort: {
+            current: defaultSort,
+            default: defaultSort,
+        } });
+}
+function createSortTraitReducer(initialState, allActions, allMutators, allConfigs) {
+    const { remote } = allConfigs.sort;
+    return createReducer(initialState, on(allActions.sortEntities, (state, { active, direction }) => !remote
+        ? allMutators.sortEntities({ active, direction }, state)
+        : Object.assign(Object.assign({}, state), { sort: Object.assign(Object.assign({}, state.sort), { current: { active, direction } }) })), on(allActions.resetEntitiesSort, (state) => {
+        var _a, _b, _c;
+        return ((_a = state.sort) === null || _a === void 0 ? void 0 : _a.default)
+            ? !remote
+                ? allMutators.sortEntities((_b = state.sort) === null || _b === void 0 ? void 0 : _b.default, state)
+                : Object.assign(Object.assign({}, state), { sort: Object.assign(Object.assign({}, state.sort), { current: (_c = state.sort) === null || _c === void 0 ? void 0 : _c.default }) })
+            : state;
+    }));
+}
+
+function createSortTraitSelectors() {
+    function selectEntitiesSort(state) {
+        var _a;
+        return (_a = state.sort) === null || _a === void 0 ? void 0 : _a.current;
+    }
+    return {
+        selectEntitiesSort,
+    };
+}
+
+function createSortTraitEffect(allActions, allConfigs) {
+    const { remote } = allConfigs.sort;
+    class SortEffect extends TraitEffect {
+        constructor() {
+            super(...arguments);
+            this.remoteSort$ = createEffect(() => {
+                return this.actions$.pipe(ofType(allActions.sortEntities, allActions.resetEntitiesSort), concatMap(() => allActions.loadEntitiesFirstPage
+                    ? [
+                        allActions.clearEntitiesPagesCache(),
+                        allActions.loadEntitiesFirstPage(),
+                    ]
+                    : [allActions.loadEntities()]));
+            });
+        }
+    }
+    SortEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: SortEffect, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    SortEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: SortEffect });
+    i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: SortEffect, decorators: [{
+                type: Injectable
+            }] });
+    return remote ? [SortEffect] : [];
+}
+
+function createSortTraitActions(actionsGroupKey, entitiesName) {
+    return {
+        sortEntities: createAction(`${actionsGroupKey} Sort ${entitiesName}`, props()),
+        resetEntitiesSort: createAction(`${actionsGroupKey} Reset ${entitiesName} Sort`),
+    };
+}
+
+/**
+ * Generates ngrx code to sort locally or remotely a list of entities
+ * @param config
+ * @param config.defaultSort - Required, Default entity prop for the sort
+ * @param config.remote - Optional field, default to false, when true disables local
+ * sorting and every sort action call will now trigger a loadEntities action and the backend
+ * should sort the data, use selectSort in the effect that call backend to get the requested sort,
+ * when false all sorting is done in memory when the sort action is fired
+ *
+ * @example
+ * // The following trait config
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>, SortState<Todo>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addSortEntitiesTrait<Todo>({
+ *        defaultSort: {active:'id', direction:'asc'}
+ *      })
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions and selectors, plus the ones generated by other traits
+ * traits.actions.sortTodos({active:'id', direction:'desc'})
+ * traits.actions.resetTodosSort()
+ *
+ * traits.selectors.selectTodosSort()
+ */
+function addSortEntitiesTrait({ remote = false, defaultSort, }) {
+    return createTraitFactory({
+        key: sortTraitKey,
+        depends: [loadEntitiesTraitKey],
+        config: { remote, defaultSort },
+        actions: ({ actionsGroupKey, entitiesName }) => createSortTraitActions(actionsGroupKey, entitiesName),
+        selectors: () => createSortTraitSelectors(),
+        mutators: ({ allSelectors, allConfigs }) => createSortTraitMutators(allSelectors, allConfigs),
+        initialState: ({ previousInitialState, allConfigs, }) => createSortInitialState(previousInitialState, allConfigs),
+        reducer: ({ initialState, allActions, allMutators, allConfigs }) => createSortTraitReducer(initialState, allActions, allMutators, allConfigs),
+        effects: ({ allActions, allConfigs }) => createSortTraitEffect(allActions, allConfigs),
+    });
+}
+
+/**
+ * Generates the ngrx code needed to reset the current state to the initial state.
+ * @param traitConfig - Config object fot the trait factory
+ * @param traitConfig.resetOn - set an extra action which will also trigger a reset state,
+ * useful if you want to create an action that reset several features states
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,FilterState<TodoFilter>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addResetEntitiesStateTrait()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions, plus the ones generated by other traits
+ * traits.actions.resetTodosState()
+ */
+function addResetEntitiesStateTrait(traitConfig = {}) {
+    return createTraitFactory({
+        key: 'reset',
+        config: traitConfig,
+        actions: ({ actionsGroupKey, entitiesName, }) => ({
+            resetEntitiesState: createAction(`${actionsGroupKey} Reset ${entitiesName} State`),
+        }),
+        reducer: ({ allActions, initialState }) => createReducer(initialState, on(allActions.resetEntitiesState, () => initialState)),
+        effects: ({ allActions }) => {
+            var _a;
+            class ResetEffect extends TraitEffect {
+                //TODO: not sure why Im forced to override this constructor
+                // or test wont pass, strangely doesnt happen in other files
+                // with similar case like pagination.effects.ts
+                constructor(actions$, store) {
+                    var _a;
+                    super(actions$, store);
+                    this.externalReset$ = ((_a = traitConfig === null || traitConfig === void 0 ? void 0 : traitConfig.resetOn) === null || _a === void 0 ? void 0 : _a.length) &&
+                        createEffect(() => {
+                            return this.actions$.pipe(ofType(...traitConfig === null || traitConfig === void 0 ? void 0 : traitConfig.resetOn), mapTo(allActions.resetEntitiesState()));
+                        });
+                }
+            }
+            ResetEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: ResetEffect, deps: [{ token: i1.Actions }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+            ResetEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: ResetEffect });
+            i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0, type: ResetEffect, decorators: [{
+                        type: Injectable
+                    }], ctorParameters: function () { return [{ type: i1.Actions }, { type: i2.Store }]; } });
+            return ((_a = traitConfig === null || traitConfig === void 0 ? void 0 : traitConfig.resetOn) === null || _a === void 0 ? void 0 : _a.length) ? [ResetEffect] : [];
+        },
+    });
+}
+
+/**
+ * Generates the typical ngrx code need to make a async action with
+ * a request, success and failure actions, plus a status property to track its progress
+ * and selectors to query the status.
+ *
+ * @param options - Config object for the trait factory
+ * @param options.name - Name of the main request action, should be in camel case
+ * @param options.actionProps - Optional param for the main request action, use the props()
+ * function for its value, if not present action will have no params,
+ * @param options.actionSuccessProps - Optional param for the request success action,
+ * use the props() function for its value, if not present action success will have no params
+ * @param options.actionFailProps - Optional param for the request fail action,
+ * use the props() function for its value, if not present action fail will have no params
+ * @returns the trait factory
+ *
+ * @example
+ * // The following trait config
+ * const traits = createEntityFeatureFactory(
+ * {entityName: 'Todo'},
+ * addAsyncActionTrait({
+ *        name: 'createClient',
+ *        actionProps: props<{ name: string }>(),
+ *        actionSuccessProps: props<{ id: string }>(),
+ *      }),
+ * )({
+ *      actionsGroupKey: 'Client',
+ *      featureSelector: createFeatureSelector<AsyncActionState<'createClient'>>(
+ *        'client',
+ *      ),
+ *    });
+ * // will generate the actions and selectors
+ * traits.actions.createClient({name:'Pedro'})
+ * traits.actions.createClientSuccess({id:'123'})
+ * traits.actions.createClientFail();
+ * traits.selectors.isLoadingCreateClient
+ * traits.selectors.isSuccessCreateClient
+ * traits.selectors.isFailCreateClient
+ */
+function addAsyncActionTrait({ name, actionProps, actionSuccessProps, actionFailProps, }) {
+    const nameAsSentence = camelCaseToSentence(name);
+    let internalActions;
+    return createTraitFactory({
+        key: name + '-call',
+        config: {
+            name,
+            actionProps,
+            actionSuccessProps,
+            actionFailProps,
+        },
+        actions: ({ actionsGroupKey, }) => {
+            internalActions = {
+                request: (actionProps
+                    ? createAction(`${actionsGroupKey} ${nameAsSentence}`, actionProps)
+                    : createAction(`${actionsGroupKey} ${nameAsSentence}`)),
+                requestSuccess: (actionSuccessProps
+                    ? createAction(`${actionsGroupKey} ${nameAsSentence} Success`, actionSuccessProps)
+                    : createAction(`${actionsGroupKey} ${nameAsSentence} Success`)),
+                requestFail: (actionFailProps
+                    ? createAction(`${actionsGroupKey} ${nameAsSentence} Failure`, actionFailProps)
+                    : createAction(`${actionsGroupKey} ${nameAsSentence} Failure`)),
+            };
+            if (name) {
+                return {
+                    [`${name}`]: internalActions.request,
+                    [`${name}Success`]: internalActions.requestSuccess,
+                    [`${name}Fail`]: internalActions.requestFail,
+                };
+            }
+            return internalActions;
+        },
+        selectors: () => {
+            function isLoadingEntity(state) {
+                return state[`${name}Status`] === 'loading';
+            }
+            function isSuccessEntity(state) {
+                return state[`${name}Status`] === 'success';
+            }
+            function isFailEntity(state) {
+                return state[`${name}Status`] === 'fail';
+            }
+            const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+            return {
+                [`isLoading${capitalizedName}`]: isLoadingEntity,
+                [`isSuccess${capitalizedName}`]: isSuccessEntity,
+                [`isFail${capitalizedName}`]: isFailEntity,
+            };
+        },
+        initialState: ({ previousInitialState }) => previousInitialState,
+        reducer: ({ initialState }) => {
+            return createReducer(initialState, on(internalActions.request, (state) => (Object.assign(Object.assign({}, state), { [`${name}Status`]: 'loading' }))), on(internalActions.requestFail, (state) => (Object.assign(Object.assign({}, state), { [`${name}Status`]: 'fail' }))), on(internalActions.requestSuccess, (state) => (Object.assign(Object.assign({}, state), { [`${name}Status`]: 'success' }))));
+        },
+    });
+}
+
+/**
+ * Generates ngrx code needed to load and entity and store it in a state
+ * @param entityName - Entity name, should be in camel case
+ * @param options.actionProps - Optional param for the main request action,
+ * use the props() function for its value, if not present action will have no params,
+ * @param options.actionSuccessProps - Optional param for the request success
+ * action, use the props() function for its value, if not present action success will have no params
+ * @param options.actionFailProps - Optional param for the request fail action,
+ * use the props() function for its value, if not present action fail will have no params
+ * @returns the trait factory
+ *
+ * @example
+ * const traits = createEntityFeatureFactory(
+ * ...addLoadEntityTraits({
+ *        entityName: 'client',
+ *        requestProps: props<{ id: string }>(),
+ *        responseProps: props<{ client: Client }>(),
+ *      }),
+ * )({
+ *      actionsGroupKey: 'Client',
+ *      featureSelector: createFeatureSelector<
+ *        LoadEntityState<Client, 'client'>
+ *        >('client'),
+ *    });
+ *
+ * // will generate
+ * traits.actions.loadClient({id:123});
+ * traits.actions.loadClientSuccess({client: {id: '123', name: 'gabs'}});
+ * traits.actions.loadClientFail();
+ * traits.selectors.selectClient
+ * traits.selectors.isLoadingLoadClient
+ * traits.selectors.isSuccessLoadClient
+ * traits.selectors.isFailLoadClient
+ */
+function addLoadEntityTraits({ entityName, actionProps, actionSuccessProps, actionFailProps, }) {
+    const capitalizedName = capitalize(entityName);
+    return [
+        addAsyncActionTrait({
+            name: ('load' + capitalizedName),
+            actionProps,
+            actionSuccessProps,
+            actionFailProps,
+        }),
+        createTraitFactory({
+            key: `load${capitalizedName}`,
+            config: { entityName, actionProps, actionSuccessProps, actionFailProps },
+            selectors: () => {
+                function selectEntity(state) {
+                    return state[`${entityName}`];
+                }
+                return {
+                    [`select${capitalizedName}`]: selectEntity,
+                };
+            },
+            initialState: ({ previousInitialState, }) => previousInitialState,
+            reducer: ({ initialState, allActions }) => {
+                return createReducer(initialState, on(allActions[`load${capitalizedName}Success`], (state, action) => (Object.assign(Object.assign({}, state), { [entityName]: action[entityName] }))));
+            },
+        }),
+    ];
+}
+
+/**
+ * Generates ngrx code needed to set and entity in the store state
+ * @param entityName - Entity name, should be in camel case
+ * @param options.actionProps - param for the main request action,
+ * use the props() function for its value
+ * @returns the trait factory
+ *
+ * @example
+ * const traits = createEntityFeatureFactory(
+ * addSetEntityTraits({
+ *        entityName: 'client',
+ *        actionProps: props<{ client: { id: number; name: string } }
+ *      }),
+ * )({
+ *      actionsGroupKey: 'Client',
+ *      featureSelector: createFeatureSelector<
+ *        SetEntityState<Client, 'client'>
+ *        >('client'),
+ *    });
+ *
+ * // will generate
+ * traits.actions.setClient({client: {id:123, name: 'gabs'}});
+ * traits.selectors.selectClient
+ */
+function addSetEntityTrait({ entityName, actionProps, }) {
+    const capitalizedName = capitalize(entityName);
+    return createTraitFactory({
+        key: `load${capitalizedName}`,
+        config: { entityName, actionProps },
+        actions: ({ actionsGroupKey }) => {
+            const setEntity = createAction(`${actionsGroupKey} Set ${capitalizedName}`, actionProps);
+            return {
+                [`set${capitalizedName}`]: setEntity,
+            };
+        },
+        selectors: () => {
+            function selectEntity(state) {
+                return state[`${entityName}`];
+            }
+            return {
+                [`select${capitalizedName}`]: selectEntity,
+            };
+        },
+        initialState: ({ previousInitialState }) => previousInitialState,
+        reducer: ({ initialState, allActions }) => {
+            return createReducer(initialState, on(allActions[`set${capitalizedName}`], (state, action) => (Object.assign(Object.assign({}, state), { [entityName]: action[entityName] }))));
+        },
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ChangeType, _isNumberValue, addAsyncActionTrait, addCrudEntitiesTrait, addEntitiesPaginationTrait, addFilterEntitiesTrait, addLoadEntitiesTrait, addLoadEntityTraits, addResetEntitiesStateTrait, addSelectEntitiesTrait, addSelectEntityTrait, addSetEntityTrait, addSortEntitiesTrait, clearEntitiesSelection, crudEntitiesTraitKey, deselectEntities, entitiesPaginationTraitKey, filterEntitiesTraitKey, loadEntitiesTraitKey, selectEntities, selectEntityTraitKey, selectTotalSelectedEntities, sortData, sortTraitKey, toggleSelectEntities };
+//# sourceMappingURL=ngrx-traits-common.js.map