@ngrx-traits/common 0.0.1

package/bundles/ngrx-traits-common.umd.js

@@ -0,0 +1,2126 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@ngrx/store'), require('@ngrx-traits/core'), require('@ngrx/entity'), require('@angular/core'), require('rxjs'), require('rxjs/operators'), require('@ngrx/effects')) :
+    typeof define === 'function' && define.amd ? define('@ngrx-traits/common', ['exports', '@ngrx/store', '@ngrx-traits/core', '@ngrx/entity', '@angular/core', 'rxjs', 'rxjs/operators', '@ngrx/effects'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global['ngrx-traits'] = global['ngrx-traits'] || {}, global['ngrx-traits'].common = {}), global.i2, global.core, global.entity, global.ng.core, global.rxjs, global.rxjs.operators, global.i1));
+}(this, (function (exports, i2, core, entity, i0, rxjs, operators, i1) { 'use strict';
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () {
+                            return e[k];
+                        }
+                    });
+                }
+            });
+        }
+        n['default'] = e;
+        return Object.freeze(n);
+    }
+
+    var i2__namespace = /*#__PURE__*/_interopNamespace(i2);
+    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
+    var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
+
+    var loadEntitiesTraitKey = 'loadEntities';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (Object.prototype.hasOwnProperty.call(b, p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+                t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); };
+    }
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+            return Reflect.metadata(metadataKey, metadataValue);
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function () { if (t[0] & 1)
+                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f)
+                throw new TypeError("Generator is already executing.");
+            while (_)
+                try {
+                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                        return t;
+                    if (y = 0, t)
+                        op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2])
+                                _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                }
+                catch (e) {
+                    op = [6, e];
+                    y = 0;
+                }
+                finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5)
+                throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+    var __createBinding = Object.create ? (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
+    }) : (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        o[k2] = m[k];
+    });
+    function __exportStar(m, o) {
+        for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+                __createBinding(o, m, p);
+    }
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+            return m.call(o);
+        if (o && typeof o.length === "number")
+            return {
+                next: function () {
+                    if (o && i >= o.length)
+                        o = void 0;
+                    return { value: o && o[i++], done: !o };
+                }
+            };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+            return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+                ar.push(r.value);
+        }
+        catch (error) {
+            e = { error: error };
+        }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"]))
+                    m.call(i);
+            }
+            finally {
+                if (e)
+                    throw e.error;
+            }
+        }
+        return ar;
+    }
+    /** @deprecated */
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+    /** @deprecated */
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+            s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2)
+            for (var i = 0, l = from.length, ar; i < l; i++) {
+                if (ar || !(i in from)) {
+                    if (!ar)
+                        ar = Array.prototype.slice.call(from, 0, i);
+                    ar[i] = from[i];
+                }
+            }
+        return to.concat(ar || from);
+    }
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n])
+            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try {
+            step(g[n](v));
+        }
+        catch (e) {
+            settle(q[0][3], e);
+        } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length)
+            resume(q[0][0], q[0][1]); }
+    }
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
+    }
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) {
+            Object.defineProperty(cooked, "raw", { value: raw });
+        }
+        else {
+            cooked.raw = raw;
+        }
+        return cooked;
+    }
+    ;
+    var __setModuleDefault = Object.create ? (function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function (o, v) {
+        o["default"] = v;
+    };
+    function __importStar(mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k in mod)
+                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    }
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+    }
+
+    function createLoadEntitiesInitialState(previousInitialState, allConfigs) {
+        if (previousInitialState === void 0) { previousInitialState = {}; }
+        var traitConfig = allConfigs.loadEntities;
+        var adapter = traitConfig.adapter;
+        return Object.assign(Object.assign(Object.assign({}, previousInitialState), adapter.getInitialState()), { status: undefined });
+    }
+    function createLoadEntitiesTraitReducer(initialState, actions, allMutators, allConfigs) {
+        var handleEntitiesMerge = !(allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.pagination);
+        return i2.createReducer.apply(void 0, __spreadArray([initialState, i2.on(actions.loadEntities, function (state) { return (Object.assign(Object.assign({}, state), { status: 'loading' })); }), i2.on(actions.loadEntitiesFail, function (state) { return (Object.assign(Object.assign({}, state), { status: 'fail' })); }), i2.on(actions.loadEntitiesSuccess, function (state) { return (Object.assign(Object.assign({}, state), { status: 'success' })); })], __read(core.insertIf(handleEntitiesMerge, function () { return i2.on(actions.loadEntitiesSuccess, function (state, _a) {
+            var entities = _a.entities;
+            return allMutators.setEntitiesList(entities, Object.assign({}, state));
+        }); }))));
+    }
+
+    function createLoadEntitiesTraitMutators(allConfigs) {
+        var _a;
+        var 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) {
+        var actions = {
+            loadEntities: i2.createAction(actionsGroupKey + " Load " + entitiesName),
+            loadEntitiesSuccess: i2.createAction(actionsGroupKey + " Load " + entitiesName + " Success", i2.props()),
+            loadEntitiesFail: i2.createAction(actionsGroupKey + " Load " + entitiesName + " Fail", function (props) { return ({ 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: selectEntitiesFilter,
+        };
+    }
+
+    function createLoadEntitiesTraitSelectors(allConfigs) {
+        var _a, _b;
+        var adapter = (_a = allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.loadEntities) === null || _a === void 0 ? void 0 : _a.adapter;
+        var entitySelectors = adapter.getSelectors();
+        var filterFunction = (_b = allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.filter) === null || _b === void 0 ? void 0 : _b.filterFn;
+        var selectors = {
+            selectEntitiesList: entitySelectors.selectAll,
+            selectEntitiesMap: entitySelectors.selectEntities,
+            selectEntitiesIdsList: entitySelectors.selectIds,
+            selectEntitiesTotal: entitySelectors.selectTotal,
+            isEntitiesLoadingFail: isFail,
+            isEntitiesLoading: isLoading,
+            isEntitiesLoadingSuccess: isSuccess,
+        };
+        if (filterFunction && entitySelectors) {
+            var selectEntitiesList = i2.createSelector(entitySelectors.selectAll, selectEntitiesFilter, function (entities, filters) { return filters ? entities.filter(function (e) { return filterFunction(filters, e); }) : entities; });
+            selectors = Object.assign(Object.assign({}, selectors), { selectEntitiesList: selectEntitiesList, selectEntitiesMap: i2.createSelector(selectors.selectEntitiesMap, selectEntitiesFilter, function (entities, filters) {
+                    var result = {};
+                    for (var id in entities) {
+                        var e = entities[id];
+                        if (filterFunction(filters, e)) {
+                            result[id] = e;
+                        }
+                    }
+                    return result;
+                }), selectEntitiesTotal: i2.createSelector(selectEntitiesList, function (entities) { return entities.length; }), selectEntitiesIdsList: i2.createSelector(selectEntitiesList, function (entities) { return entities.map(function (e) { return 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) {
+        var adapter = entity.createEntityAdapter(traitConfig);
+        return core.createTraitFactory({
+            key: loadEntitiesTraitKey,
+            config: Object.assign(Object.assign({}, traitConfig), { adapter: adapter }),
+            actions: function (_a) {
+                var actionsGroupKey = _a.actionsGroupKey, entitiesName = _a.entitiesName;
+                return createLoadEntitiesTraitActions(actionsGroupKey, entitiesName);
+            },
+            selectors: function (_a) {
+                var allConfigs = _a.allConfigs;
+                return createLoadEntitiesTraitSelectors(allConfigs);
+            },
+            mutators: function (_a) {
+                var allConfigs = _a.allConfigs;
+                return createLoadEntitiesTraitMutators(allConfigs);
+            },
+            initialState: function (_a) {
+                var previousInitialState = _a.previousInitialState, allConfigs = _a.allConfigs;
+                return createLoadEntitiesInitialState(previousInitialState, allConfigs);
+            },
+            reducer: function (_a) {
+                var initialState = _a.initialState, allActions = _a.allActions, allMutators = _a.allMutators, allConfigs = _a.allConfigs;
+                return createLoadEntitiesTraitReducer(initialState, allActions, allMutators, allConfigs);
+            },
+        });
+    }
+
+    var entitiesPaginationTraitKey = 'pagination';
+
+    function createFilterTraitEffects(allActions, allSelectors, allConfigs) {
+        var traitConfig = allConfigs.filter;
+        var FilterEffect = /** @class */ (function (_super) {
+            __extends(FilterEffect, _super);
+            function FilterEffect() {
+                var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+                _this.storeFilter$ = i1.createEffect(function () { return function (_a) {
+                    var _b = _a === void 0 ? {} : _a, _c = _b.debounce, debounceTime = _c === void 0 ? traitConfig.defaultDebounceTime : _c, _d = _b.scheduler, scheduler = _d === void 0 ? rxjs.asyncScheduler : _d;
+                    return _this.actions$.pipe(i1.ofType(allActions.filterEntities), operators.debounce(function (value) { return (value === null || value === void 0 ? void 0 : value.forceLoad) ? rxjs.EMPTY : rxjs.timer(debounceTime, scheduler); }), operators.concatMap(function (payload) { return payload.patch
+                        ? _this.store.select(allSelectors.selectEntitiesFilter).pipe(operators.first(), operators.map(function (storedFilters) { return (Object.assign(Object.assign({}, payload), { filters: Object.assign(Object.assign({}, storedFilters), payload === null || payload === void 0 ? void 0 : payload.filters) })); }))
+                        : rxjs.of(payload); }), operators.distinctUntilChanged(function (previous, current) { return !(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)
+                        ? rxjs.pipe(operators.startWith({
+                            filters: traitConfig.defaultFilter,
+                            patch: false,
+                        }), operators.pairwise(), operators.concatMap(function (_a) {
+                            var _b = __read(_a, 2), previous = _b[0], current = _b[1];
+                            return (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,
+                                    }),
+                                ];
+                        }))
+                        : operators.map(function (action) { return 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)) &&
+                    i1.createEffect(function () {
+                        return _this.actions$.pipe(i1.ofType(allActions['storeEntitiesFilter']), operators.concatMap(function () { return (allActions === null || allActions === void 0 ? void 0 : allActions.loadEntitiesFirstPage)
+                            ? [
+                                allActions.clearEntitiesPagesCache(),
+                                allActions.loadEntitiesFirstPage(),
+                            ]
+                            : [allActions.loadEntities()]; }));
+                    });
+                return _this;
+            }
+            return FilterEffect;
+        }(core.TraitEffect));
+        FilterEffect.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: FilterEffect, deps: null, target: i0__namespace.ɵɵFactoryTarget.Injectable });
+        FilterEffect.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: FilterEffect });
+        i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: FilterEffect, decorators: [{
+                    type: i0.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 i2.createReducer(initialState, i2.on(allActions.storeEntitiesFilter, function (state, _b) {
+            var filters = _b.filters;
+            return allMutators.setEntitiesFilters(filters, state);
+        }));
+    }
+
+    var filterEntitiesTraitKey = 'filter';
+
+    function createFilterTraitMutators() {
+        function setEntitiesFilters(filters, state) {
+            return Object.assign(Object.assign({}, state), { filters: filters });
+        }
+        return { setEntitiesFilters: setEntitiesFilters };
+    }
+
+    function createFilterTraitActions(actionsGroupKey, entitiesName) {
+        var actions = {
+            filterEntities: i2.createAction(actionsGroupKey + " Filter " + entitiesName, function (props) { return ({
+                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: i2.createAction(actionsGroupKey + " Store " + entitiesName + " Filter", function (props) { return ({
+                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(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.defaultDebounceTime, defaultDebounceTime = _c === void 0 ? 400 : _c, defaultFilter = _b.defaultFilter, filterFn = _b.filterFn, isRemoteFilter = _b.isRemoteFilter;
+        return core.createTraitFactory({
+            key: filterEntitiesTraitKey,
+            depends: [entitiesPaginationTraitKey, loadEntitiesTraitKey],
+            config: {
+                defaultDebounceTime: defaultDebounceTime,
+                defaultFilter: defaultFilter,
+                filterFn: filterFn,
+                isRemoteFilter: isRemoteFilter,
+            },
+            actions: function (_a) {
+                var actionsGroupKey = _a.actionsGroupKey, entitiesName = _a.entitiesName;
+                return createFilterTraitActions(actionsGroupKey, entitiesName);
+            },
+            selectors: function () { return createFilterTraitSelectors(); },
+            mutators: function () { return createFilterTraitMutators(); },
+            initialState: function (_a) {
+                var previousInitialState = _a.previousInitialState, allConfigs = _a.allConfigs;
+                return createFilterInitialState(previousInitialState, allConfigs);
+            },
+            reducer: function (_a) {
+                var initialState = _a.initialState, allActions = _a.allActions, allMutators = _a.allMutators;
+                return createFilterTraitReducer(initialState, allActions, allMutators);
+            },
+            effects: function (_a) {
+                var allActions = _a.allActions, allSelectors = _a.allSelectors, allConfigs = _a.allConfigs;
+                return createFilterTraitEffects(allActions, allSelectors, allConfigs);
+            },
+        });
+    }
+
+    function createPaginationTraitSelectors(previousSelectors, allConfigs) {
+        var _a;
+        var selectEntitiesList = previousSelectors.selectEntitiesList, isEntitiesLoading = previousSelectors.isEntitiesLoading;
+        var 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;
+        }
+        var selectPaginationFiltered = filterFunction
+            ? i2.createSelector(selectEntitiesList, selectPagination, function (entities, pagination) {
+                return Object.assign(Object.assign({}, pagination), { total: entities.length, cache: Object.assign(Object.assign({}, pagination.cache), { start: 0, end: entities.length }) });
+            })
+            : selectPagination;
+        var selectPageEntitiesList = i2.createSelector(selectEntitiesList, selectPaginationFiltered, function (entities, pagination, _b) {
+            var _c = _b === void 0 ? { page: pagination.currentPage } : _b, page = _c.page;
+            var startIndex = page * pagination.pageSize - pagination.cache.start;
+            var endIndex = startIndex + pagination.pageSize;
+            endIndex =
+                endIndex < pagination.cache.end ? endIndex : pagination.cache.end;
+            return entities.slice(startIndex, endIndex);
+        });
+        var selectEntitiesPageInfo = i2.createSelector(selectPaginationFiltered, function (pagination) {
+            var pagesCount = pagination.total && pagination.total > 0
+                ? Math.ceil(pagination.total / pagination.pageSize)
+                : undefined;
+            return {
+                pageIndex: pagination.currentPage,
+                total: pagination.total,
+                pageSize: pagination.pageSize,
+                pagesCount: pagesCount,
+                hasPrevious: pagination.currentPage - 1 >= 0,
+                hasNext: pagination.total && pagination.total > 0
+                    ? pagination.currentPage + 1 < pagesCount
+                    : true,
+                cacheType: pagination.cache.type,
+            };
+        });
+        var isEntitiesPageInCache = i2.createSelector(selectPaginationFiltered, function (pagination, _b) {
+            var _c = _b === void 0 ? { page: pagination.currentPage } : _b, page = _c.page;
+            var startIndex = page * pagination.pageSize;
+            var endIndex = startIndex + pagination.pageSize - 1;
+            endIndex =
+                pagination.total && endIndex > pagination.total
+                    ? pagination.total - 1
+                    : endIndex;
+            return (startIndex >= pagination.cache.start && endIndex <= pagination.cache.end);
+        });
+        var selectEntitiesPage = i2.createSelector(selectPageEntitiesList, selectEntitiesPageInfo, 
+        // props look unsued but they are pass to the selectPageEntities
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        function (entities, pageInfo, props) {
+            if (props === void 0) { props = { page: pageInfo.pageIndex }; }
+            return (Object.assign({ entities: entities }, pageInfo));
+        });
+        var selectEntitiesPagedRequest = i2.createSelector(selectPagination, function (pagination) { return ({
+            startIndex: pagination.pageSize * pagination.requestPage,
+            size: pagination.pageSize * pagination.pagesToCache,
+            page: pagination.requestPage,
+        }); });
+        var isLoadingEntitiesPage = i2.createSelector(isEntitiesLoading, selectPagination, function (isLoading, pagination) { return isLoading && pagination.requestPage === pagination.currentPage; });
+        return {
+            selectPageEntitiesList: selectPageEntitiesList,
+            isEntitiesPageInCache: isEntitiesPageInCache,
+            selectEntitiesPage: selectEntitiesPage,
+            selectEntitiesPagedRequest: selectEntitiesPagedRequest,
+            selectEntitiesPageInfo: selectEntitiesPageInfo,
+            isLoadingEntitiesPage: isLoadingEntitiesPage,
+        };
+    }
+
+    function createPaginationTraitActions(actionsGroupKey, entitiesName) {
+        var actions = {
+            loadEntitiesPage: i2.createAction(actionsGroupKey + " Load " + entitiesName + " Page", function (_a) {
+                var index = _a.index, forceLoad = _a.forceLoad;
+                return ({
+                    index: index,
+                    forceLoad: forceLoad,
+                });
+            }),
+            loadEntitiesPageSuccess: i2.createAction(actionsGroupKey + " Load  " + entitiesName + "\n          Page Success"),
+            loadEntitiesPageFail: i2.createAction(actionsGroupKey + " Load " + entitiesName + " Page Fail"),
+            loadEntitiesPreviousPage: i2.createAction(actionsGroupKey + " Load Previous " + entitiesName + " Page"),
+            loadEntitiesNextPage: i2.createAction(actionsGroupKey + " Load Next " + entitiesName + " Page"),
+            loadEntitiesFirstPage: i2.createAction(actionsGroupKey + " Load First " + entitiesName + " Page", function (forceLoad) { return ({ forceLoad: forceLoad }); }),
+            loadEntitiesLastPage: i2.createAction(actionsGroupKey + " Load Last " + entitiesName + " Page"),
+            clearEntitiesPagesCache: i2.createAction(actionsGroupKey + " Clear " + entitiesName + " Cache"),
+            setEntitiesRequestPage: i2.createAction(actionsGroupKey + " Set " + entitiesName + " Request Page", i2.props()),
+        };
+        return actions;
+    }
+
+    function createPaginationInitialState(previousInitialState, allConfigs) {
+        var _b = allConfigs.pagination, currentPage = _b.currentPage, pageSize = _b.pageSize, cacheType = _b.cacheType, pagesToCache = _b.pagesToCache;
+        return Object.assign(Object.assign({}, previousInitialState), { pagination: {
+                pageSize: pageSize,
+                currentPage: currentPage,
+                requestPage: currentPage,
+                pagesToCache: 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) {
+            var total = allSelectors.selectEntitiesTotal(state);
+            return Object.assign(Object.assign({}, state), { status: 'success', pagination: Object.assign(Object.assign({}, state.pagination), { currentPage: 0, total: total, cache: Object.assign(Object.assign({}, state.pagination.cache), { start: 0, end: total }) }) });
+        }
+        var filterRemote = !((_a = allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.filter) === null || _a === void 0 ? void 0 : _a.filterFn);
+        return i2.createReducer.apply(void 0, __spreadArray(__spreadArray(__spreadArray(__spreadArray([initialState, i2.on(allActions.loadEntitiesPage, function (state, _b) {
+                var index = _b.index;
+                return (Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { currentPage: index, requestPage: index }), status: 'loading' }));
+            }), i2.on(allActions.setEntitiesRequestPage, function (state, _b) {
+                var index = _b.index;
+                return (Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { requestPage: index }), status: 'loading' }));
+            }), i2.on(allActions.loadEntitiesPageSuccess, function (state) { return (Object.assign(Object.assign({}, state), { status: 'success' })); }), i2.on(allActions.loadEntitiesPageFail, function (state) { return (Object.assign(Object.assign({}, state), { status: 'fail' })); }), i2.on(allActions.clearEntitiesPagesCache, function (state) { return clearPagesCache(state); }), i2.on(allActions.loadEntitiesSuccess, function (state, _b) {
+                var entities = _b.entities, total = _b.total;
+                return allMutators.mergePaginatedEntities(entities, total, Object.assign(Object.assign({}, state), { status: 'success' }));
+            })], __read(core.insertIf(allActions.addEntities, function () { return i2.on(allActions.addEntities, function (state, _b) {
+            var entities = _b.entities;
+            return addToCacheTotal(state, entities.length);
+        }); }))), __read(core.insertIf(allActions.removeEntities, function () { return i2.on(allActions.removeEntities, function (state, _b) {
+            var keys = _b.keys;
+            return addToCacheTotal(state, -keys.length);
+        }); }))), __read(core.insertIf(filterRemote && allActions.filterEntities, function () { return i2.on(allActions.filterEntities, function (state) { return recalculateTotal(state); }); }))), __read(core.insertIf(allActions.removeAllEntities, function () { return i2.on(allActions.removeAllEntities, function (state) { return clearPagesCache(state); }); }))));
+    }
+
+    function createPaginationTraitEffects(allActions, allSelectors) {
+        var PaginationEffect = /** @class */ (function (_super) {
+            __extends(PaginationEffect, _super);
+            function PaginationEffect() {
+                var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+                _this.loadPage$ = i1.createEffect(function () {
+                    return _this.actions$.pipe(i1.ofType(allActions.loadEntitiesPage), i1.concatLatestFrom(function () { return _this.store.select(allSelectors.isEntitiesPageInCache); }), operators.map(function (_a) {
+                        var _b = __read(_a, 2), forceLoad = _b[0].forceLoad, isInCache = _b[1];
+                        return !forceLoad && isInCache
+                            ? allActions.loadEntitiesPageSuccess()
+                            : allActions.loadEntities();
+                    }));
+                });
+                _this.preloadNextPage$ = i1.createEffect(function () {
+                    return _this.actions$.pipe(i1.ofType(allActions.loadEntitiesPageSuccess), operators.concatMapTo(_this.store.select(allSelectors.selectEntitiesPageInfo).pipe(operators.first())), operators.filter(function (pageInfo) { return !!pageInfo.total &&
+                        pageInfo.hasNext &&
+                        pageInfo.cacheType !== 'full'; }), operators.concatMap(function (pageInfo) { return _this.store
+                        .select(allSelectors.isEntitiesPageInCache, {
+                        page: pageInfo.pageIndex + 1,
+                    })
+                        .pipe(operators.first(), operators.map(function (isInCache) { return (!isInCache && pageInfo) || undefined; })); }), operators.filter(function (pageInfo) { return !!pageInfo; }), operators.concatMap(function (pageInfo) { return [
+                        allActions.setEntitiesRequestPage({ index: pageInfo.pageIndex + 1 }),
+                        allActions.loadEntities(),
+                    ]; }));
+                });
+                _this.loadFirstPage$ = i1.createEffect(function () {
+                    return _this.actions$.pipe(i1.ofType(allActions.loadEntitiesFirstPage), operators.map(function () { return allActions.loadEntitiesPage({ index: 0 }); }));
+                });
+                _this.loadPreviousPage$ = i1.createEffect(function () {
+                    return _this.actions$.pipe(i1.ofType(allActions.loadEntitiesPreviousPage), operators.concatMapTo(_this.store.select(allSelectors.selectEntitiesPageInfo).pipe(operators.first())), operators.map(function (page) { return page.hasPrevious
+                        ? allActions.loadEntitiesPage({ index: page.pageIndex - 1 })
+                        : allActions.loadEntitiesPageFail(); }));
+                });
+                _this.loadNextPage$ = i1.createEffect(function () {
+                    return _this.actions$.pipe(i1.ofType(allActions.loadEntitiesNextPage), operators.concatMapTo(_this.store.select(allSelectors.selectEntitiesPageInfo).pipe(operators.first())), operators.map(function (page) { return page.hasNext
+                        ? allActions.loadEntitiesPage({ index: page.pageIndex + 1 })
+                        : allActions.loadEntitiesPageFail(); }));
+                });
+                _this.loadLastPage$ = i1.createEffect(function () {
+                    return _this.actions$.pipe(i1.ofType(allActions.loadEntitiesLastPage), operators.concatMapTo(_this.store.select(allSelectors.selectEntitiesPageInfo).pipe(operators.first())), operators.map(function (page) { return page.hasNext && page.pagesCount
+                        ? allActions.loadEntitiesPage({ index: page.pagesCount - 1 })
+                        : allActions.loadEntitiesPageFail(); }));
+                });
+                return _this;
+            }
+            return PaginationEffect;
+        }(core.TraitEffect));
+        PaginationEffect.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: PaginationEffect, deps: null, target: i0__namespace.ɵɵFactoryTarget.Injectable });
+        PaginationEffect.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: PaginationEffect });
+        i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: PaginationEffect, decorators: [{
+                    type: i0.Injectable
+                }] });
+        return [PaginationEffect];
+    }
+
+    function createPaginationTraitMutators(allSelectors, allConfigs) {
+        var adapter = allConfigs.loadEntities.adapter;
+        function mergePaginatedEntities(entities, total, state) {
+            if (total === void 0) { total = undefined; }
+            var 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': {
+                    var isPreloadNextPages = state.pagination.currentPage + 1 === state.pagination.requestPage;
+                    var start = state.pagination.currentPage * state.pagination.pageSize;
+                    var newEntities = isPreloadNextPages
+                        ? __spreadArray(__spreadArray([], __read(allSelectors.selectPageEntitiesList(state))), __read(entities)) : entities;
+                    return adapter.setAll(newEntities, Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { total: total, cache: Object.assign(Object.assign({}, state.pagination.cache), { start: start, end: start + entities.length }) }) }));
+                }
+                case 'grow':
+                    return adapter.addMany(entities, Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { total: total, cache: Object.assign(Object.assign({}, state.pagination.cache), { end: state.ids.length + entities.length }) }) }));
+            }
+            return state;
+        }
+        return { mergePaginatedEntities: 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(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.cacheType, cacheType = _c === void 0 ? 'full' : _c, _d = _b.pageSize, pageSize = _d === void 0 ? 20 : _d, _e = _b.currentPage, currentPage = _e === void 0 ? 0 : _e, _f = _b.pagesToCache, pagesToCache = _f === void 0 ? 3 : _f;
+        return core.createTraitFactory({
+            key: entitiesPaginationTraitKey,
+            depends: [loadEntitiesTraitKey],
+            config: {
+                cacheType: cacheType,
+                pageSize: pageSize,
+                currentPage: currentPage,
+                pagesToCache: pagesToCache,
+            },
+            actions: function (_a) {
+                var actionsGroupKey = _a.actionsGroupKey, entitiesName = _a.entitiesName;
+                return createPaginationTraitActions(actionsGroupKey, entitiesName);
+            },
+            selectors: function (_a) {
+                var previousSelectors = _a.previousSelectors, allConfigs = _a.allConfigs;
+                return createPaginationTraitSelectors(previousSelectors, allConfigs);
+            },
+            mutators: function (_a) {
+                var allSelectors = _a.allSelectors, allConfigs = _a.allConfigs;
+                return createPaginationTraitMutators(allSelectors, allConfigs);
+            },
+            initialState: function (_a) {
+                var previousInitialState = _a.previousInitialState, allConfigs = _a.allConfigs;
+                return createPaginationInitialState(previousInitialState, allConfigs);
+            },
+            reducer: function (_a) {
+                var initialState = _a.initialState, allActions = _a.allActions, allSelectors = _a.allSelectors, allMutators = _a.allMutators, allConfigs = _a.allConfigs;
+                return createPaginationTraitReducer(initialState, allActions, allSelectors, allMutators, allConfigs);
+            },
+            effects: function (_a) {
+                var allActions = _a.allActions, allSelectors = _a.allSelectors;
+                return createPaginationTraitEffects(allActions, allSelectors);
+            },
+        });
+    }
+
+    function createSelectEntitiesTraitActions(actionsGroupKey, entitiesName) {
+        return {
+            selectEntities: i2.createAction(actionsGroupKey + " Select " + entitiesName, i2.props()),
+            deselectEntities: i2.createAction(actionsGroupKey + " Deselect " + entitiesName, i2.props()),
+            toggleSelectEntities: i2.createAction(actionsGroupKey + " Toggle Select " + entitiesName, i2.props()),
+            toggleSelectAllEntities: i2.createAction(actionsGroupKey + " Toggle Select All " + entitiesName),
+            clearEntitiesSelection: i2.createAction(actionsGroupKey + " Clear " + entitiesName + " Selection"),
+        };
+    }
+
+    function deselectEntities(id, state) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        var _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) {
+        var _c;
+        return Object.assign(Object.assign({}, state), { selectedIds: Object.assign(Object.assign({}, state.selectedIds), (_c = {}, _c[id] = true, _c)) });
+    }
+    function toggleSelectEntities(id, state) {
+        var 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) {
+        var selectEntitiesMap = previousSelectors.selectEntitiesMap, selectEntitiesTotal = previousSelectors.selectEntitiesTotal;
+        function selectEntitiesIdsSelectedMap(state) {
+            return state.selectedIds;
+        }
+        var selectEntitiesIdsSelectedList = i2.createSelector(selectEntitiesIdsSelectedMap, function (ids) { return Object.keys(ids); });
+        var selectEntitiesSelectedMap = i2.createSelector(selectEntitiesIdsSelectedList, selectEntitiesMap, function (selectedIds, entities) { return selectedIds.reduce(function (acum, id) {
+            acum[id] = entities[id];
+            return acum;
+        }, {}); });
+        var selectEntitiesSelectedList = i2.createSelector(selectEntitiesIdsSelectedList, selectEntitiesMap, function (selectedIds, entities) { return selectedIds.map(function (id) { return entities[id]; }); });
+        var isAllEntitiesSelected = i2.createSelector(function (state) { return selectEntitiesTotal(state); }, selectTotalSelectedEntities, function (total, totalSelected) { return totalSelected > 0 && totalSelected === total
+            ? 'all'
+            : totalSelected === 0
+                ? 'none'
+                : 'some'; });
+        return {
+            selectEntitiesIdsSelectedMap: selectEntitiesIdsSelectedMap,
+            selectEntitiesIdsSelectedList: selectEntitiesIdsSelectedList,
+            selectEntitiesSelectedMap: selectEntitiesSelectedMap,
+            selectEntitiesSelectedList: selectEntitiesSelectedList,
+            selectTotalSelectedEntities: selectTotalSelectedEntities,
+            isAllEntitiesSelected: isAllEntitiesSelected,
+        };
+    }
+
+    function createSelectEntitiesInitialState(previousInitialState) {
+        return Object.assign(Object.assign({}, previousInitialState), { selectedIds: {} });
+    }
+    function createSelectEntitiesTraitReducer(initialState, allActions, allMutators, allConfigs) {
+        var _a, _b;
+        var adapter = allConfigs.loadEntities.adapter;
+        var sortRemote = (_a = allConfigs.sort) === null || _a === void 0 ? void 0 : _a.remote;
+        var paginationCacheType = (_b = allConfigs.pagination) === null || _b === void 0 ? void 0 : _b.cacheType;
+        function updateSelectedIdsChanged(state, updates) {
+            var changedIds = updates.reduce(function (acc, updated) {
+                var 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) {
+                var selectedIds_1 = Object.assign({}, state.selectedIds);
+                changedIds.forEach(function (updated) {
+                    var id = adapter.selectId(updated.changes);
+                    var value = selectedIds_1[updated.id];
+                    delete selectedIds_1[updated.id];
+                    selectedIds_1[id] = value;
+                });
+                return Object.assign(Object.assign({}, state), { selectedIds: selectedIds_1 });
+            }
+            return state;
+        }
+        return i2.createReducer.apply(void 0, __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([initialState, i2.on(allActions.selectEntities, function (state, _c) {
+                var id = _c.id;
+                return allMutators.selectEntities(id, state);
+            }), i2.on(allActions.deselectEntities, function (state, _c) {
+                var id = _c.id;
+                return allMutators.deselectEntities(id, state);
+            }), i2.on(allActions.toggleSelectEntities, function (state, _c) {
+                var id = _c.id;
+                return allMutators.toggleSelectEntities(id, state);
+            }), i2.on(allActions.toggleSelectAllEntities, function (state) { return allMutators.toggleSelectAllEntities(state); })], __read(core.insertIf(allActions.removeEntities, function () { return i2.on(allActions.removeEntities, function (state, _c) {
+            var keys = _c.keys;
+            var selectedIds = Object.assign({}, state.selectedIds);
+            keys.forEach(function (v) {
+                delete selectedIds[v];
+            });
+            return Object.assign(Object.assign({}, state), { selectedIds: selectedIds });
+        }); }))), __read(core.insertIf(allActions.updateEntities, function () { return i2.on(allActions.updateEntities, function (state, _c) {
+            var updates = _c.updates;
+            return updateSelectedIdsChanged(state, updates);
+        }); }))), [i2.on(allActions.clearEntitiesSelection, function (state) { return allMutators.clearEntitiesSelection(state); })]), __read(core.insertIf(allActions.removeAllEntities, function () { return i2.on(allActions.removeAllEntities, function (state) { return allMutators.clearEntitiesSelection(state); }); }))), __read(core.insertIf(sortRemote, function () { return i2.on(allActions.sortEntities, function (state) { return allMutators.clearEntitiesSelection(state); }); }))), __read(core.insertIf(allActions.filterEntities, function () { return i2.on(allActions.filterEntities, function (state) { return allMutators.clearEntitiesSelection(state); }); }))), __read(core.insertIf(!allActions.loadEntitiesPageSuccess, function () { return i2.on(allActions.loadEntitiesSuccess, function (state) { return allMutators.clearEntitiesSelection(state); }); }))), __read(core.insertIf(!!allActions.loadEntitiesPageSuccess && paginationCacheType === 'partial', function () { return i2.on(allActions.loadEntitiesPageSuccess, function (state) { return allMutators.clearEntitiesSelection(state); }); }))));
+    }
+
+    function createSelectEntitiesTraitMutators(_a) {
+        var isAllEntitiesSelected = _a.isAllEntitiesSelected;
+        function toggleSelectAllEntities(state) {
+            var allSelected = isAllEntitiesSelected(state);
+            if (allSelected === 'all') {
+                return Object.assign(Object.assign({}, state), { selectedIds: {} });
+            }
+            else {
+                return Object.assign(Object.assign({}, state), { selectedIds: core.toMap(state.ids) });
+            }
+        }
+        return {
+            selectEntities: selectEntities,
+            deselectEntities: deselectEntities,
+            toggleSelectEntities: toggleSelectEntities,
+            toggleSelectAllEntities: toggleSelectAllEntities,
+            clearEntitiesSelection: 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 core.createTraitFactory({
+            key: 'SelectEntities',
+            depends: [loadEntitiesTraitKey],
+            actions: function (_a) {
+                var actionsGroupKey = _a.actionsGroupKey, entitiesName = _a.entitiesName;
+                return createSelectEntitiesTraitActions(actionsGroupKey, entitiesName);
+            },
+            selectors: function (_a) {
+                var previousSelectors = _a.previousSelectors;
+                return createSelectEntitiesTraitSelectors(previousSelectors);
+            },
+            initialState: function (_a) {
+                var previousInitialState = _a.previousInitialState;
+                return createSelectEntitiesInitialState(previousInitialState);
+            },
+            mutators: function (_a) {
+                var allSelectors = _a.allSelectors;
+                return createSelectEntitiesTraitMutators(allSelectors);
+            },
+            reducer: function (_a) {
+                var initialState = _a.initialState, allActions = _a.allActions, allMutators = _a.allMutators, allConfigs = _a.allConfigs;
+                return createSelectEntitiesTraitReducer(initialState, allActions, allMutators, allConfigs);
+            },
+        });
+    }
+
+    function createSelectEntityTraitActions(actionsGroupKey, entityName) {
+        return {
+            selectEntity: i2.createAction(actionsGroupKey + " Select " + entityName, i2.props()),
+            deselectEntity: i2.createAction(actionsGroupKey + " Deselect " + entityName),
+            toggleSelectEntity: i2.createAction(actionsGroupKey + " Toggle Select " + entityName, i2.props()),
+        };
+    }
+
+    function createSelectEntityTraitSelectors() {
+        function selectEntityIdSelected(state) {
+            return state.selectedId;
+        }
+        function selectEntitySelected(state) {
+            return (state.selectedId && state.entities[state.selectedId]) || undefined;
+        }
+        return {
+            selectEntityIdSelected: selectEntityIdSelected,
+            selectEntitySelected: selectEntitySelected,
+        };
+    }
+
+    function createSelectEntityInitialState(previousInitialState, allConfigs) {
+        var _a;
+        var selectedId = (_a = allConfigs.singleSelection) === null || _a === void 0 ? void 0 : _a.selectedId;
+        return Object.assign(Object.assign({}, previousInitialState), { selectedId: selectedId });
+    }
+    function createSelectEntityTraitReducer(initialState, allActions, allMutators, allConfigs) {
+        var _a, _b;
+        var adapter = allConfigs.loadEntities.adapter;
+        var sortRemote = (_a = allConfigs.sort) === null || _a === void 0 ? void 0 : _a.remote;
+        var paginationCacheType = (_b = allConfigs.pagination) === null || _b === void 0 ? void 0 : _b.cacheType;
+        return i2.createReducer.apply(void 0, __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([initialState, i2.on(allActions.selectEntity, function (state, _c) {
+                var id = _c.id;
+                return allMutators.selectEntity(id, state);
+            }), i2.on(allActions.deselectEntity, function (state) { return allMutators.deselectEntity(state); }), i2.on(allActions.toggleSelectEntity, function (state, _c) {
+                var id = _c.id;
+                return allMutators.toggleSelectEntity(id, state);
+            })], __read(core.insertIf(allActions.removeAllEntities, function () { return i2.on(allActions.removeAllEntities, function (state) { return allMutators.deselectEntity(state); }); }))), __read(core.insertIf(sortRemote, function () { return i2.on(allActions.sortEntities, function (state) { return allMutators.deselectEntity(state); }); }))), __read(core.insertIf(allActions.filterEntities, function () { return i2.on(allActions.filterEntities, function (state) { return allMutators.deselectEntity(state); }); }))), __read(core.insertIf(!allActions.loadEntitiesPageSuccess, function () { return i2.on(allActions.loadEntitiesSuccess, function (state) { return allMutators.deselectEntity(state); }); }))), __read(core.insertIf(!!allActions.loadEntitiesPageSuccess && paginationCacheType === 'partial', function () { return i2.on(allActions.loadEntitiesPageSuccess, function (state) { return allMutators.deselectEntity(state); }); }))), __read(core.insertIf(allActions.removeEntities, function () { return i2.on(allActions.removeEntities, function (state, _c) {
+            var keys = _c.keys;
+            var shouldDeselect = keys.some(function (v) { return v === state.selectedId; });
+            return shouldDeselect
+                ? Object.assign(Object.assign({}, state), { selectedId: undefined }) : state;
+        }); }))), __read(core.insertIf(allActions.updateEntities, function () { return i2.on(allActions.updateEntities, function (state, _c) {
+            var updates = _c.updates;
+            var change = updates.find(function (updated) {
+                var 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: selectEntity,
+            deselectEntity: deselectEntity,
+            toggleSelectEntity: 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 core.createTraitFactory({
+            key: 'singleSelection',
+            depends: [loadEntitiesTraitKey],
+            config: config,
+            actions: function (_a) {
+                var actionsGroupKey = _a.actionsGroupKey, entityName = _a.entityName;
+                return createSelectEntityTraitActions(actionsGroupKey, entityName);
+            },
+            selectors: function () { return createSelectEntityTraitSelectors(); },
+            mutators: function () { return createSelectEntityTraitMutators(); },
+            initialState: function (_a) {
+                var previousInitialState = _a.previousInitialState, allConfigs = _a.allConfigs;
+                return createSelectEntityInitialState(previousInitialState, allConfigs);
+            },
+            reducer: function (_a) {
+                var initialState = _a.initialState, allActions = _a.allActions, allMutators = _a.allMutators, allConfigs = _a.allConfigs;
+                return createSelectEntityTraitReducer(initialState, allActions, allMutators, allConfigs);
+            },
+        });
+    }
+
+    var selectEntityTraitKey = 'singleSelection';
+
+    exports.ChangeType = void 0;
+    (function (ChangeType) {
+        ChangeType["CREATED"] = "c";
+        ChangeType["UPDATED"] = "u";
+        ChangeType["DELETED"] = "d";
+    })(exports.ChangeType || (exports.ChangeType = {}));
+    var crudEntitiesTraitKey = 'crud';
+
+    function createCrudTraitActions(actionsGroupKey, entitiesName) {
+        return {
+            addEntities: i2.createAction(actionsGroupKey + " Add " + entitiesName, function () {
+                var entities = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    entities[_i] = arguments[_i];
+                }
+                return ({
+                    entities: entities,
+                });
+            }),
+            removeEntities: i2.createAction(actionsGroupKey + " Remove " + entitiesName, function () {
+                var keys = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    keys[_i] = arguments[_i];
+                }
+                return ({
+                    keys: keys,
+                });
+            }),
+            updateEntities: i2.createAction(actionsGroupKey + " Update " + entitiesName, function () {
+                var updates = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    updates[_i] = arguments[_i];
+                }
+                return ({
+                    updates: updates,
+                });
+            }),
+            upsertEntities: i2.createAction(actionsGroupKey + " Upsert " + entitiesName, function () {
+                var entities = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    entities[_i] = arguments[_i];
+                }
+                return ({
+                    entities: entities,
+                });
+            }),
+            removeAllEntities: i2.createAction(actionsGroupKey + " Remove All " + entitiesName, function (predicate) { return ({ predicate: predicate }); }),
+            clearEntitiesChanges: i2.createAction(actionsGroupKey + " Clear  " + entitiesName + " Changes"),
+        };
+    }
+
+    function createCrudTraitSelectors(previousSelectors) {
+        function selectChanges(state) {
+            return state.changes;
+        }
+        function selectFilteredChanges(state) {
+            var cache = {};
+            return state.changes.reduce(function (acc, value) {
+                var changes = cache[value.id];
+                if (!changes) {
+                    cache[value.id] = [value.changeType];
+                    acc.push(value);
+                    return acc;
+                }
+                if (value.changeType === exports.ChangeType.UPDATED) {
+                    return acc;
+                }
+                if (value.changeType === exports.ChangeType.DELETED &&
+                    changes.includes(exports.ChangeType.CREATED)) {
+                    delete cache[value.id];
+                    return acc.filter(function (v) { return v.id !== value.id; });
+                }
+                if (value.changeType === exports.ChangeType.DELETED) {
+                    delete cache[value.id];
+                    var newAcc = acc.filter(function (v) { return v.id !== value.id; });
+                    newAcc.push(value);
+                    return newAcc;
+                }
+                return acc;
+            }, []);
+        }
+        var selectEntitiesMap = previousSelectors.selectEntitiesMap;
+        var selectEntitiesChangesList = i2.createSelector(function (state) { return selectEntitiesMap(state); }, selectChanges, function (entities, changed, _b) {
+            var type = _b.type;
+            if (type)
+                return changed
+                    .filter(function (c) { return c.changeType === type; })
+                    .map(function (change) {
+                    var _a;
+                    return ({
+                        changeType: change.changeType,
+                        entity: (_a = entities[change.id]) !== null && _a !== void 0 ? _a : {
+                            id: change.id,
+                        },
+                    });
+                });
+            var map = changed.map(function (change) {
+                var _a;
+                return ({
+                    changeType: change.changeType,
+                    entity: (_a = entities[change.id]) !== null && _a !== void 0 ? _a : {
+                        id: change.id,
+                    },
+                });
+            });
+            return map;
+        });
+        var selectFilteredEntitiesChangesList = i2.createSelector(selectFilteredChanges, function (state) { return selectEntitiesMap(state); }, function (changes, entities) { return changes.map(function (c) {
+            var _a;
+            return {
+                entity: (_a = entities[c.id]) !== null && _a !== void 0 ? _a : { id: c.id },
+                changeType: c.changeType,
+            };
+        }); });
+        return {
+            selectEntitiesChangesList: selectEntitiesChangesList,
+            selectFilteredEntitiesChangesList: selectFilteredEntitiesChangesList,
+        };
+    }
+
+    function createCrudInitialState(previousInitialState) {
+        return Object.assign(Object.assign({}, previousInitialState), { changes: [] });
+    }
+    function createCrudTraitReducer(initialState, allActions, allMutators, allConfigs) {
+        var _a, _b, _c;
+        var sortRemote = (_a = allConfigs.sort) === null || _a === void 0 ? void 0 : _a.remote;
+        var filterRemote = allConfigs.filter && !((_b = allConfigs.filter) === null || _b === void 0 ? void 0 : _b.filterFn);
+        var paginationCacheType = (_c = allConfigs.pagination) === null || _c === void 0 ? void 0 : _c.cacheType;
+        return i2.createReducer.apply(void 0, __spreadArray(__spreadArray(__spreadArray(__spreadArray([initialState, i2.on(allActions.addEntities, function (state, _d) {
+                var entities = _d.entities;
+                return allMutators.addEntities(entities, state);
+            }), i2.on(allActions.updateEntities, function (state, _d) {
+                var updates = _d.updates;
+                return allMutators.updateEntities(updates, state);
+            }), i2.on(allActions.upsertEntities, function (state, _d) {
+                var entities = _d.entities;
+                return allMutators.upsertEntities(entities, state);
+            }), i2.on(allActions.removeEntities, function (state, _d) {
+                var keys = _d.keys;
+                return allMutators.removeEntities(keys, state);
+            }), i2.on(allActions.removeAllEntities, function (state, _d) {
+                var predicate = _d.predicate;
+                return predicate
+                    ? allMutators.removeEntities(predicate, state)
+                    : allMutators.removeAllEntities(state);
+            }), i2.on(allActions.clearEntitiesChanges, function (state) { return allMutators.clearEntitiesChanges(state); })], __read(core.insertIf(sortRemote, function () { return i2.on(allActions.sortEntities, function (state) { return allMutators.clearEntitiesChanges(state); }); }))), __read(core.insertIf(filterRemote, function () { return i2.on(allActions.filterEntities, function (state) { return allMutators.clearEntitiesChanges(state); }); }))), __read(core.insertIf(!allActions.loadEntitiesPageSuccess, function () { return i2.on(allActions.loadEntitiesSuccess, function (state) { return allMutators.clearEntitiesChanges(state); }); }))), __read(core.insertIf(!!allActions.loadEntitiesPageSuccess && paginationCacheType === 'partial', function () { return i2.on(allActions.loadEntitiesPageSuccess, function (state) { return allMutators.clearEntitiesChanges(state); }); }))));
+    }
+
+    function createCrudTraitMutators(allConfigs) {
+        var storeChanges = (allConfigs.crud || {}).storeChanges;
+        var adapter = allConfigs.loadEntities.adapter;
+        function generateChangeEntry(entity, changeType, customId) {
+            return {
+                id: customId !== null && customId !== void 0 ? customId : adapter.selectId(entity),
+                changeType: changeType,
+                entityChanges: (storeChanges && entity) || undefined,
+            };
+        }
+        function addEntities(entities, state, addFirst) {
+            if (addFirst === void 0) { addFirst = false; }
+            var changes = __spreadArray(__spreadArray([], __read(state.changes)), __read(entities.map(function (entity) { return generateChangeEntry(entity, exports.ChangeType.CREATED); })));
+            if (!addFirst)
+                return adapter.addMany(entities, Object.assign(Object.assign({}, state), { changes: changes }));
+            var newIds = entities.map(function (e) { return adapter.selectId(e); });
+            var newEntities = Object.assign({}, state.entities);
+            entities.forEach(function (e) {
+                var id = adapter.selectId(e);
+                newEntities[id] = e;
+            });
+            return Object.assign(Object.assign({}, state), { ids: __spreadArray(__spreadArray([], __read(newIds)), __read(state.ids)), entities: newEntities, changes: changes });
+        }
+        function upsertEntities(entities, state) {
+            var oldChanges = __spreadArray([], __read(state.changes));
+            var existingIds = adapter.getSelectors().selectIds(state);
+            var _b = __read(entities.reduce(function (_b, entity) {
+                var _c = __read(_b, 2), a = _c[0], u = _c[1];
+                return existingIds.indexOf(adapter.selectId(entity)) !== -1
+                    ? [a, __spreadArray(__spreadArray([], __read(u)), [entity])]
+                    : [__spreadArray(__spreadArray([], __read(a)), [entity]), u];
+            }, [new Array(), new Array()]), 2), additions = _b[0], updates = _b[1];
+            return adapter.upsertMany(entities, Object.assign(Object.assign({}, state), { changes: __spreadArray(__spreadArray(__spreadArray([], __read(oldChanges)), __read(additions.map(function (entity) { return generateChangeEntry(entity, exports.ChangeType.CREATED); }))), __read(updates.map(function (entity) { return generateChangeEntry(entity, exports.ChangeType.UPDATED); }))) }));
+        }
+        function removeEntities(keysOrPredicate, state) {
+            if (typeof keysOrPredicate === 'function') {
+                return adapter.removeMany(keysOrPredicate, Object.assign(Object.assign({}, state), { changes: __spreadArray(__spreadArray([], __read(state.changes)), __read(state.ids.map(function (id) { return ({
+                        id: id,
+                        changeType: exports.ChangeType.DELETED,
+                    }); }))) }));
+            }
+            return adapter.removeMany(keysOrPredicate, Object.assign(Object.assign({}, state), { changes: __spreadArray(__spreadArray([], __read(state.changes)), __read(keysOrPredicate.map(function (key) { return ({
+                    id: key,
+                    changeType: exports.ChangeType.DELETED,
+                }); }))) }));
+        }
+        function removeAllEntities(state) {
+            return adapter.removeAll(Object.assign(Object.assign({}, state), { changes: __spreadArray(__spreadArray([], __read(state.changes)), __read(state.ids.map(function (id) { return ({
+                    id: id,
+                    changeType: exports.ChangeType.DELETED,
+                }); }))) }));
+        }
+        function clearEntitiesChanges(state) {
+            return Object.assign(Object.assign({}, state), { changes: [] });
+        }
+        function updateEntities(updates, state) {
+            var oldChanges = __spreadArray([], __read(state.changes));
+            updates.forEach(function (updated) {
+                var id = adapter.selectId(updated.changes);
+                if (id && id !== updated.id) {
+                    // if the id changes update the id of pold changes
+                    var index = oldChanges.findIndex(function (v) { return v.id === updated.id; });
+                    var oldChange = oldChanges[index];
+                    oldChanges[index] = Object.assign(Object.assign({}, oldChange), { id: id });
+                }
+            });
+            return adapter.updateMany(updates, Object.assign(Object.assign({}, state), { changes: __spreadArray(__spreadArray([], __read(oldChanges)), __read(updates.map(function (updated) {
+                    var _a;
+                    return ({
+                        id: (_a = adapter.selectId(updated.changes)) !== null && _a !== void 0 ? _a : updated.id,
+                        changeType: exports.ChangeType.UPDATED,
+                        entityChanges: (storeChanges && updated.changes) || undefined,
+                    });
+                }))) }));
+        }
+        return {
+            addEntities: addEntities,
+            removeEntities: removeEntities,
+            updateEntities: updateEntities,
+            removeAllEntities: removeAllEntities,
+            clearEntitiesChanges: clearEntitiesChanges,
+            upsertEntities: 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(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.storeChanges, storeChanges = _c === void 0 ? false : _c;
+        return core.createTraitFactory({
+            key: crudEntitiesTraitKey,
+            depends: [loadEntitiesTraitKey],
+            config: { storeChanges: storeChanges },
+            actions: function (_a) {
+                var actionsGroupKey = _a.actionsGroupKey, entitiesName = _a.entitiesName;
+                return createCrudTraitActions(actionsGroupKey, entitiesName);
+            },
+            selectors: function (_a) {
+                var previousSelectors = _a.previousSelectors;
+                return createCrudTraitSelectors(previousSelectors);
+            },
+            mutators: function (_a) {
+                var allConfigs = _a.allConfigs;
+                return createCrudTraitMutators(allConfigs);
+            },
+            initialState: function (_a) {
+                var previousInitialState = _a.previousInitialState;
+                return createCrudInitialState(previousInitialState);
+            },
+            reducer: function (_a) {
+                var initialState = _a.initialState, allActions = _a.allActions, allMutators = _a.allMutators, allConfigs = _a.allConfigs;
+                return createCrudTraitReducer(initialState, allActions, allMutators, allConfigs);
+            },
+        });
+    }
+
+    var sortTraitKey = 'sort';
+
+    var 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) {
+        var value = data[sortHeaderId];
+        if (_isNumberValue(value)) {
+            var 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) {
+        var active = sort.active;
+        var direction = sort.direction;
+        if (!active || direction === '') {
+            return data;
+        }
+        return data.sort(function (a, b) {
+            var valueA = sortingDataAccessor(a, active);
+            var 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).
+            var 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(_a, allConfigs) {
+        var selectEntitiesList = _a.selectEntitiesList;
+        function sortEntities(_a, state) {
+            var active = _a.active, direction = _a.direction;
+            var adapter = allConfigs.loadEntities.adapter;
+            var entities = selectEntitiesList(state);
+            var sortedIds = sortData(entities, { active: active, direction: direction }).map(function (v) { return adapter.selectId(v); });
+            return Object.assign(Object.assign({}, state), { ids: sortedIds, sort: Object.assign(Object.assign({}, state.sort), { current: { active: active, direction: direction } }) });
+        }
+        return {
+            sortEntities: sortEntities,
+        };
+    }
+
+    function createSortInitialState(previousInitialState, allConfigs) {
+        var defaultSort = allConfigs.sort.defaultSort;
+        return Object.assign(Object.assign({}, previousInitialState), { sort: {
+                current: defaultSort,
+                default: defaultSort,
+            } });
+    }
+    function createSortTraitReducer(initialState, allActions, allMutators, allConfigs) {
+        var remote = allConfigs.sort.remote;
+        return i2.createReducer(initialState, i2.on(allActions.sortEntities, function (state, _d) {
+            var active = _d.active, direction = _d.direction;
+            return !remote
+                ? allMutators.sortEntities({ active: active, direction: direction }, state)
+                : Object.assign(Object.assign({}, state), { sort: Object.assign(Object.assign({}, state.sort), { current: { active: active, direction: direction } }) });
+        }), i2.on(allActions.resetEntitiesSort, function (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: selectEntitiesSort,
+        };
+    }
+
+    function createSortTraitEffect(allActions, allConfigs) {
+        var remote = allConfigs.sort.remote;
+        var SortEffect = /** @class */ (function (_super) {
+            __extends(SortEffect, _super);
+            function SortEffect() {
+                var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+                _this.remoteSort$ = i1.createEffect(function () {
+                    return _this.actions$.pipe(i1.ofType(allActions.sortEntities, allActions.resetEntitiesSort), operators.concatMap(function () { return allActions.loadEntitiesFirstPage
+                        ? [
+                            allActions.clearEntitiesPagesCache(),
+                            allActions.loadEntitiesFirstPage(),
+                        ]
+                        : [allActions.loadEntities()]; }));
+                });
+                return _this;
+            }
+            return SortEffect;
+        }(core.TraitEffect));
+        SortEffect.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: SortEffect, deps: null, target: i0__namespace.ɵɵFactoryTarget.Injectable });
+        SortEffect.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: SortEffect });
+        i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: SortEffect, decorators: [{
+                    type: i0.Injectable
+                }] });
+        return remote ? [SortEffect] : [];
+    }
+
+    function createSortTraitActions(actionsGroupKey, entitiesName) {
+        return {
+            sortEntities: i2.createAction(actionsGroupKey + " Sort " + entitiesName, i2.props()),
+            resetEntitiesSort: i2.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(_a) {
+        var _b = _a.remote, remote = _b === void 0 ? false : _b, defaultSort = _a.defaultSort;
+        return core.createTraitFactory({
+            key: sortTraitKey,
+            depends: [loadEntitiesTraitKey],
+            config: { remote: remote, defaultSort: defaultSort },
+            actions: function (_a) {
+                var actionsGroupKey = _a.actionsGroupKey, entitiesName = _a.entitiesName;
+                return createSortTraitActions(actionsGroupKey, entitiesName);
+            },
+            selectors: function () { return createSortTraitSelectors(); },
+            mutators: function (_a) {
+                var allSelectors = _a.allSelectors, allConfigs = _a.allConfigs;
+                return createSortTraitMutators(allSelectors, allConfigs);
+            },
+            initialState: function (_a) {
+                var previousInitialState = _a.previousInitialState, allConfigs = _a.allConfigs;
+                return createSortInitialState(previousInitialState, allConfigs);
+            },
+            reducer: function (_a) {
+                var initialState = _a.initialState, allActions = _a.allActions, allMutators = _a.allMutators, allConfigs = _a.allConfigs;
+                return createSortTraitReducer(initialState, allActions, allMutators, allConfigs);
+            },
+            effects: function (_a) {
+                var allActions = _a.allActions, allConfigs = _a.allConfigs;
+                return 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) {
+        if (traitConfig === void 0) { traitConfig = {}; }
+        return core.createTraitFactory({
+            key: 'reset',
+            config: traitConfig,
+            actions: function (_b) {
+                var actionsGroupKey = _b.actionsGroupKey, entitiesName = _b.entitiesName;
+                return ({
+                    resetEntitiesState: i2.createAction(actionsGroupKey + " Reset " + entitiesName + " State"),
+                });
+            },
+            reducer: function (_b) {
+                var allActions = _b.allActions, initialState = _b.initialState;
+                return i2.createReducer(initialState, i2.on(allActions.resetEntitiesState, function () { return initialState; }));
+            },
+            effects: function (_b) {
+                var allActions = _b.allActions;
+                var _a;
+                var ResetEffect = /** @class */ (function (_super) {
+                    __extends(ResetEffect, _super);
+                    //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
+                    function ResetEffect(actions$, store) {
+                        var _this = this;
+                        var _a;
+                        _this = _super.call(this, actions$, store) || this;
+                        _this.externalReset$ = ((_a = traitConfig === null || traitConfig === void 0 ? void 0 : traitConfig.resetOn) === null || _a === void 0 ? void 0 : _a.length) &&
+                            i1.createEffect(function () {
+                                return _this.actions$.pipe(i1.ofType.apply(void 0, __spreadArray([], __read(traitConfig === null || traitConfig === void 0 ? void 0 : traitConfig.resetOn))), operators.mapTo(allActions.resetEntitiesState()));
+                            });
+                        return _this;
+                    }
+                    return ResetEffect;
+                }(core.TraitEffect));
+                ResetEffect.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: ResetEffect, deps: [{ token: i1__namespace.Actions }, { token: i2__namespace.Store }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+                ResetEffect.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: ResetEffect });
+                i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: ResetEffect, decorators: [{
+                            type: i0.Injectable
+                        }], ctorParameters: function () { return [{ type: i1__namespace.Actions }, { type: i2__namespace.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(_a) {
+        var name = _a.name, actionProps = _a.actionProps, actionSuccessProps = _a.actionSuccessProps, actionFailProps = _a.actionFailProps;
+        var nameAsSentence = core.camelCaseToSentence(name);
+        var internalActions;
+        return core.createTraitFactory({
+            key: name + '-call',
+            config: {
+                name: name,
+                actionProps: actionProps,
+                actionSuccessProps: actionSuccessProps,
+                actionFailProps: actionFailProps,
+            },
+            actions: function (_a) {
+                var _b;
+                var actionsGroupKey = _a.actionsGroupKey;
+                internalActions = {
+                    request: (actionProps
+                        ? i2.createAction(actionsGroupKey + " " + nameAsSentence, actionProps)
+                        : i2.createAction(actionsGroupKey + " " + nameAsSentence)),
+                    requestSuccess: (actionSuccessProps
+                        ? i2.createAction(actionsGroupKey + " " + nameAsSentence + " Success", actionSuccessProps)
+                        : i2.createAction(actionsGroupKey + " " + nameAsSentence + " Success")),
+                    requestFail: (actionFailProps
+                        ? i2.createAction(actionsGroupKey + " " + nameAsSentence + " Failure", actionFailProps)
+                        : i2.createAction(actionsGroupKey + " " + nameAsSentence + " Failure")),
+                };
+                if (name) {
+                    return _b = {},
+                        _b["" + name] = internalActions.request,
+                        _b[name + "Success"] = internalActions.requestSuccess,
+                        _b[name + "Fail"] = internalActions.requestFail,
+                        _b;
+                }
+                return internalActions;
+            },
+            selectors: function () {
+                var _a;
+                function isLoadingEntity(state) {
+                    return state[name + "Status"] === 'loading';
+                }
+                function isSuccessEntity(state) {
+                    return state[name + "Status"] === 'success';
+                }
+                function isFailEntity(state) {
+                    return state[name + "Status"] === 'fail';
+                }
+                var capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+                return _a = {},
+                    _a["isLoading" + capitalizedName] = isLoadingEntity,
+                    _a["isSuccess" + capitalizedName] = isSuccessEntity,
+                    _a["isFail" + capitalizedName] = isFailEntity,
+                    _a;
+            },
+            initialState: function (_a) {
+                var previousInitialState = _a.previousInitialState;
+                return previousInitialState;
+            },
+            reducer: function (_a) {
+                var initialState = _a.initialState;
+                return i2.createReducer(initialState, i2.on(internalActions.request, function (state) {
+                    var _a;
+                    return (Object.assign(Object.assign({}, state), (_a = {}, _a[name + "Status"] = 'loading', _a)));
+                }), i2.on(internalActions.requestFail, function (state) {
+                    var _a;
+                    return (Object.assign(Object.assign({}, state), (_a = {}, _a[name + "Status"] = 'fail', _a)));
+                }), i2.on(internalActions.requestSuccess, function (state) {
+                    var _a;
+                    return (Object.assign(Object.assign({}, state), (_a = {}, _a[name + "Status"] = 'success', _a)));
+                }));
+            },
+        });
+    }
+
+    /**
+     * 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(_a) {
+        var entityName = _a.entityName, actionProps = _a.actionProps, actionSuccessProps = _a.actionSuccessProps, actionFailProps = _a.actionFailProps;
+        var capitalizedName = core.capitalize(entityName);
+        return [
+            addAsyncActionTrait({
+                name: ('load' + capitalizedName),
+                actionProps: actionProps,
+                actionSuccessProps: actionSuccessProps,
+                actionFailProps: actionFailProps,
+            }),
+            core.createTraitFactory({
+                key: "load" + capitalizedName,
+                config: { entityName: entityName, actionProps: actionProps, actionSuccessProps: actionSuccessProps, actionFailProps: actionFailProps },
+                selectors: function () {
+                    var _a;
+                    function selectEntity(state) {
+                        return state["" + entityName];
+                    }
+                    return _a = {},
+                        _a["select" + capitalizedName] = selectEntity,
+                        _a;
+                },
+                initialState: function (_a) {
+                    var previousInitialState = _a.previousInitialState;
+                    return previousInitialState;
+                },
+                reducer: function (_a) {
+                    var initialState = _a.initialState, allActions = _a.allActions;
+                    return i2.createReducer(initialState, i2.on(allActions["load" + capitalizedName + "Success"], function (state, action) {
+                        var _a;
+                        return (Object.assign(Object.assign({}, state), (_a = {}, _a[entityName] = action[entityName], _a)));
+                    }));
+                },
+            }),
+        ];
+    }
+
+    /**
+     * 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(_a) {
+        var entityName = _a.entityName, actionProps = _a.actionProps;
+        var capitalizedName = core.capitalize(entityName);
+        return core.createTraitFactory({
+            key: "load" + capitalizedName,
+            config: { entityName: entityName, actionProps: actionProps },
+            actions: function (_a) {
+                var _b;
+                var actionsGroupKey = _a.actionsGroupKey;
+                var setEntity = i2.createAction(actionsGroupKey + " Set " + capitalizedName, actionProps);
+                return _b = {},
+                    _b["set" + capitalizedName] = setEntity,
+                    _b;
+            },
+            selectors: function () {
+                var _a;
+                function selectEntity(state) {
+                    return state["" + entityName];
+                }
+                return _a = {},
+                    _a["select" + capitalizedName] = selectEntity,
+                    _a;
+            },
+            initialState: function (_a) {
+                var previousInitialState = _a.previousInitialState;
+                return previousInitialState;
+            },
+            reducer: function (_a) {
+                var initialState = _a.initialState, allActions = _a.allActions;
+                return i2.createReducer(initialState, i2.on(allActions["set" + capitalizedName], function (state, action) {
+                    var _a;
+                    return (Object.assign(Object.assign({}, state), (_a = {}, _a[entityName] = action[entityName], _a)));
+                }));
+            },
+        });
+    }
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    exports._isNumberValue = _isNumberValue;
+    exports.addAsyncActionTrait = addAsyncActionTrait;
+    exports.addCrudEntitiesTrait = addCrudEntitiesTrait;
+    exports.addEntitiesPaginationTrait = addEntitiesPaginationTrait;
+    exports.addFilterEntitiesTrait = addFilterEntitiesTrait;
+    exports.addLoadEntitiesTrait = addLoadEntitiesTrait;
+    exports.addLoadEntityTraits = addLoadEntityTraits;
+    exports.addResetEntitiesStateTrait = addResetEntitiesStateTrait;
+    exports.addSelectEntitiesTrait = addSelectEntitiesTrait;
+    exports.addSelectEntityTrait = addSelectEntityTrait;
+    exports.addSetEntityTrait = addSetEntityTrait;
+    exports.addSortEntitiesTrait = addSortEntitiesTrait;
+    exports.clearEntitiesSelection = clearEntitiesSelection;
+    exports.crudEntitiesTraitKey = crudEntitiesTraitKey;
+    exports.deselectEntities = deselectEntities;
+    exports.entitiesPaginationTraitKey = entitiesPaginationTraitKey;
+    exports.filterEntitiesTraitKey = filterEntitiesTraitKey;
+    exports.loadEntitiesTraitKey = loadEntitiesTraitKey;
+    exports.selectEntities = selectEntities;
+    exports.selectEntityTraitKey = selectEntityTraitKey;
+    exports.selectTotalSelectedEntities = selectTotalSelectedEntities;
+    exports.sortData = sortData;
+    exports.sortTraitKey = sortTraitKey;
+    exports.toggleSelectEntities = toggleSelectEntities;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=ngrx-traits-common.umd.js.map