ngrx-entity-crud 12.0.6-beta.2

package/bundles/ngrx-entity-crud.umd.js

@@ -0,0 +1,1829 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@ngrx/entity'), require('@ngrx/store'), require('rxjs/operators'), require('@angular/core'), require('@ngrx/effects'), require('rxjs'), require('@angular/common/http')) :
+    typeof define === 'function' && define.amd ? define('ngrx-entity-crud', ['exports', '@ngrx/entity', '@ngrx/store', 'rxjs/operators', '@angular/core', '@ngrx/effects', 'rxjs', '@angular/common/http'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['ngrx-entity-crud'] = {}, global.entity, global.store, global.rxjs.operators, global.ng.core, global.effects, global.rxjs, global.ng.common.http));
+}(this, (function (exports, entity, store, operators, i0, effects, rxjs, 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 i0__namespace = /*#__PURE__*/_interopNamespace(i0);
+    var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
+
+    exports.CrudEnum = void 0;
+    (function (CrudEnum) {
+        CrudEnum["SEARCH"] = "Search";
+        CrudEnum["DELETE"] = "Delete";
+        CrudEnum["CREATE"] = "Create";
+        CrudEnum["EDIT"] = "Edit";
+        CrudEnum["SELECT"] = "Select";
+        CrudEnum["RESET"] = "Reset";
+    })(exports.CrudEnum || (exports.CrudEnum = {}));
+    exports.ActionEnum = void 0;
+    (function (ActionEnum) {
+        ActionEnum["RESPONSE"] = "Response";
+        ActionEnum["REQUEST"] = "Request";
+        ActionEnum["FAILURE"] = "Failure";
+        ActionEnum["SUCCESS"] = "Success";
+    })(exports.ActionEnum || (exports.ActionEnum = {}));
+
+    function getInitialEntityCrudState() {
+        return {
+            ids: [],
+            entities: {},
+            isLoading: false,
+            isLoaded: false,
+            error: null,
+            filters: {},
+            lastCriteria: null,
+            entitiesSelected: {},
+            idsSelected: [],
+            itemSelected: null,
+            idSelected: null,
+            responses: []
+        };
+    }
+    function createInitialCrudStateFactory() {
+        function getInitialCrudState(additionalState) {
+            if (additionalState === void 0) { additionalState = {}; }
+            return Object.assign(getInitialEntityCrudState(), additionalState);
+        }
+        return { getInitialCrudState: getInitialCrudState };
+    }
+
+    var isEmpty = function (obj) {
+        return obj === null || undefined
+            ? true
+            : (function () {
+                for (var prop in obj) {
+                    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+                        return false;
+                    }
+                }
+                return true;
+            })();
+    };
+    function jNgrxFilter(items, filters) {
+        return new JNgrxFilter().jNgrxFilter(items, filters);
+    }
+    var JNgrxFilter = /** @class */ (function () {
+        function JNgrxFilter() {
+            this.filterConstraints = {
+                startsWith: function (value, filter) {
+                    if (filter === undefined || filter === null || filter.trim() === '') {
+                        return true;
+                    }
+                    if (value === undefined || value === null) {
+                        return false;
+                    }
+                    var filterValue = filter.toLowerCase();
+                    return value.toString().toLowerCase().slice(0, filterValue.length) === filterValue;
+                },
+                contains: function (value, filter) {
+                    if (filter === undefined || filter === null || (typeof filter === 'string' && filter.trim() === '')) {
+                        return true;
+                    }
+                    if (value === undefined || value === null) {
+                        return false;
+                    }
+                    return value.toString().toLowerCase().indexOf(filter.toLowerCase()) !== -1;
+                },
+                endsWith: function (value, filter) {
+                    if (filter === undefined || filter === null || filter.trim() === '') {
+                        return true;
+                    }
+                    if (value === undefined || value === null) {
+                        return false;
+                    }
+                    var filterValue = filter.toString().toLowerCase();
+                    return value.toString().toLowerCase().indexOf(filterValue, value.toString().length - filterValue.length) !== -1;
+                },
+                equals: function (value, filter) {
+                    if (filter === undefined || filter === null || (typeof filter === 'string' && filter.trim() === '')) {
+                        return true;
+                    }
+                    if (value === undefined || value === null) {
+                        return false;
+                    }
+                    return value.toString().toLowerCase() === filter.toString().toLowerCase();
+                },
+                notEquals: function (value, filter) {
+                    if (filter === undefined || filter === null || (typeof filter === 'string' && filter.trim() === '')) {
+                        return false;
+                    }
+                    if (value === undefined || value === null) {
+                        return true;
+                    }
+                    return value.toString().toLowerCase() !== filter.toString().toLowerCase();
+                },
+                in: function (value, filters) {
+                    if (filters === undefined || filters === null || filters.length === 0) {
+                        return true;
+                    }
+                    if (value === undefined || value === null) {
+                        return false;
+                    }
+                    filters.forEach(function (filter) {
+                        if (filter === value) {
+                            return true;
+                        }
+                    });
+                    return false;
+                }
+            };
+            this.isFunction = function (obj) { return !!(obj && obj.constructor && obj.call && obj.apply); };
+        }
+        JNgrxFilter.prototype.jNgrxFilter = function (items, filters) {
+            var _this = this;
+            if (isEmpty(filters)) {
+                return items;
+            }
+            var filteredValue = [];
+            items.forEach(function (item) {
+                var localMatch = false;
+                // tslint:disable-next-line:forin
+                for (var filterField in filters) {
+                    var filterValue = filters[filterField].value;
+                    var filterMatchMode = filters[filterField].matchMode || 'startsWith';
+                    var filterConstraint = _this.filterConstraints[filterMatchMode];
+                    var renderFunction = filters[filterField].renderFunction;
+                    var dataFieldValue = _this.isFunction(renderFunction) ? renderFunction(_this.resolveFieldData(item, filterField)) : _this.resolveFieldData(item, filterField);
+                    if (filterConstraint(dataFieldValue, filterValue)) {
+                        localMatch = true;
+                        break;
+                    }
+                }
+                if (localMatch) {
+                    filteredValue.push(item);
+                }
+            });
+            return filteredValue;
+        };
+        JNgrxFilter.prototype.resolveFieldData = function (data, field) {
+            if (data && field) {
+                if (this.isFunction(field)) {
+                    return field(data);
+                }
+                else if (field.indexOf('.') === -1) {
+                    return data[field];
+                }
+                else {
+                    var fields = field.split('.');
+                    var value = data;
+                    for (var i = 0, len = fields.length; i < len; ++i) {
+                        if (value == null) {
+                            return null;
+                        }
+                        value = value[fields[i]];
+                    }
+                    return value;
+                }
+            }
+            else {
+                return null;
+            }
+        };
+        return JNgrxFilter;
+    }());
+
+    function createCrudSelectorsFactory(adapter) {
+        function getCrudSelectors(selectState) {
+            var getError = function (state) { return state.error; };
+            var getIsLoading = function (state) { return state.isLoading; };
+            var getIsLoaded = function (state) { return state.isLoaded; };
+            var getFilters = function (state) { return state.filters; };
+            var getLastCriteria = function (state) { return state.lastCriteria; };
+            var getItemSelected = function (state) { return state.itemSelected; };
+            var getIdSelected = function (state) { return state.idSelected; };
+            // const getItemsSelected = (state: CrudState<T>): T[] => state.itemsSelected;
+            var getEntitiesSelected = function (state) { return state.entitiesSelected; };
+            var getIdsSelected = function (state) { return state.idsSelected; };
+            var getRespones = function (state) { return state.responses; };
+            var selectError = store.createSelector(selectState, getError);
+            var selectIsLoading = store.createSelector(selectState, getIsLoading);
+            var selectIsLoaded = store.createSelector(selectState, getIsLoaded);
+            var selectFilters = store.createSelector(selectState, getFilters);
+            var selectLastCriteria = store.createSelector(selectState, getLastCriteria);
+            var selectItemSelected = store.createSelector(selectState, getItemSelected);
+            var selectEntitiesSelected = store.createSelector(selectState, getEntitiesSelected);
+            var selectItemsSelected = store.createSelector(selectEntitiesSelected, function (entities) { return Object.values(entities); });
+            var selectIdSelected = store.createSelector(selectState, getIdSelected);
+            var selectIdsSelected = store.createSelector(selectState, getIdsSelected);
+            var selectResponses = store.createSelector(selectState, getRespones);
+            var _a = adapter.getSelectors(selectState), selectAll = _a.selectAll, selectEntities = _a.selectEntities, selectIds = _a.selectIds, selectTotal = _a.selectTotal;
+            var selectItemsSelectedOrigin = store.createSelector(selectIdsSelected, selectEntities, function (ids, entities) { return ids.map(function (id) { return entities[id]; }); });
+            var selectItemSelectedOrigin = store.createSelector(selectIdSelected, selectEntities, function (id, entities) { return entities[id]; });
+            var selectFilteredItems = store.createSelector([selectAll, selectFilters], function (allTasks, filters) {
+                return jNgrxFilter(allTasks, filters);
+            });
+            return {
+                selectError: selectError,
+                selectIsLoading: selectIsLoading,
+                selectIsLoaded: selectIsLoaded,
+                selectFilters: selectFilters,
+                selectFilteredItems: selectFilteredItems,
+                selectAll: selectAll,
+                selectEntities: selectEntities,
+                selectIds: selectIds,
+                selectTotal: selectTotal,
+                selectLastCriteria: selectLastCriteria,
+                selectIdSelected: selectIdSelected,
+                selectItemSelected: selectItemSelected,
+                selectItemSelectedOrigin: selectItemSelectedOrigin,
+                selectIdsSelected: selectIdsSelected,
+                selectItemsSelected: selectItemsSelected,
+                selectEntitiesSelected: selectEntitiesSelected,
+                selectItemsSelectedOrigin: selectItemsSelectedOrigin,
+                selectResponses: selectResponses,
+            };
+        }
+        return { getCrudSelectors: getCrudSelectors };
+    }
+
+    function createCrudActionsFactory() {
+        function createCrudActions(name) {
+            // tslint:disable:variable-name
+            /**
+             * mode:
+             *  comportamento predefinito, il dato attualmente presente viene cancellato e ripopolato al result della chiamata
+             *  REFRESH => il dato viene sostituito al result della chiamata.
+             */
+            var Response = store.createAction("[" + name + "] " + exports.ActionEnum.RESPONSE, store.props());
+            var ResetResponses = store.createAction("[" + name + "] " + exports.CrudEnum.RESET + " " + exports.ActionEnum.RESPONSE);
+            var SearchRequest = store.createAction("[" + name + "] " + exports.CrudEnum.SEARCH + " " + exports.ActionEnum.REQUEST, store.props());
+            var SearchFailure = store.createAction("[" + name + "] " + exports.CrudEnum.SEARCH + " " + exports.ActionEnum.FAILURE, store.props());
+            var SearchSuccess = store.createAction("[" + name + "] " + exports.CrudEnum.SEARCH + " " + exports.ActionEnum.SUCCESS, store.props());
+            var DeleteRequest = store.createAction("[" + name + "] " + exports.CrudEnum.DELETE + " " + exports.ActionEnum.REQUEST, store.props());
+            var DeleteFailure = store.createAction("[" + name + "] " + exports.CrudEnum.DELETE + " " + exports.ActionEnum.FAILURE, store.props());
+            var DeleteSuccess = store.createAction("[" + name + "] " + exports.CrudEnum.DELETE + " " + exports.ActionEnum.SUCCESS, store.props());
+            var DeleteManyRequest = store.createAction("[" + name + "] " + exports.CrudEnum.DELETE + " many " + exports.ActionEnum.REQUEST, store.props());
+            var DeleteManyFailure = store.createAction("[" + name + "] " + exports.CrudEnum.DELETE + " many " + exports.ActionEnum.FAILURE, store.props());
+            var DeleteManySuccess = store.createAction("[" + name + "] " + exports.CrudEnum.DELETE + " many " + exports.ActionEnum.SUCCESS, store.props());
+            var CreateRequest = store.createAction("[" + name + "] " + exports.CrudEnum.CREATE + " " + exports.ActionEnum.REQUEST, store.props());
+            var CreateFailure = store.createAction("[" + name + "] " + exports.CrudEnum.CREATE + " " + exports.ActionEnum.FAILURE, store.props());
+            var CreateSuccess = store.createAction("[" + name + "] " + exports.CrudEnum.CREATE + " " + exports.ActionEnum.SUCCESS, store.props());
+            var CreateManyRequest = store.createAction("[" + name + "] " + exports.CrudEnum.CREATE + " many " + exports.ActionEnum.REQUEST, store.props());
+            var CreateManyFailure = store.createAction("[" + name + "] " + exports.CrudEnum.CREATE + " many " + exports.ActionEnum.FAILURE, store.props());
+            var CreateManySuccess = store.createAction("[" + name + "] " + exports.CrudEnum.CREATE + " many " + exports.ActionEnum.SUCCESS, store.props());
+            var SelectRequest = store.createAction("[" + name + "] " + exports.CrudEnum.SELECT + " " + exports.ActionEnum.REQUEST, store.props());
+            var SelectFailure = store.createAction("[" + name + "] " + exports.CrudEnum.SELECT + " " + exports.ActionEnum.FAILURE, store.props());
+            var SelectSuccess = store.createAction("[" + name + "] " + exports.CrudEnum.SELECT + " " + exports.ActionEnum.SUCCESS, store.props());
+            var EditRequest = store.createAction("[" + name + "] " + exports.CrudEnum.EDIT + " " + exports.ActionEnum.REQUEST, store.props());
+            var EditFailure = store.createAction("[" + name + "] " + exports.CrudEnum.EDIT + " " + exports.ActionEnum.FAILURE, store.props());
+            var EditSuccess = store.createAction("[" + name + "] " + exports.CrudEnum.EDIT + " " + exports.ActionEnum.SUCCESS, store.props());
+            var EditManyRequest = store.createAction("[" + name + "] " + exports.CrudEnum.EDIT + " many " + exports.ActionEnum.REQUEST, store.props());
+            var EditManyFailure = store.createAction("[" + name + "] " + exports.CrudEnum.EDIT + " many " + exports.ActionEnum.FAILURE, store.props());
+            var EditManySuccess = store.createAction("[" + name + "] " + exports.CrudEnum.EDIT + " many " + exports.ActionEnum.SUCCESS, store.props());
+            var Reset = store.createAction("[" + name + "] " + exports.CrudEnum.RESET);
+            var Filters = store.createAction("[" + name + "] Filters", store.props());
+            var SelectItems = store.createAction("[" + name + "] SelectItems", store.props());
+            var AddManySelected = store.createAction("[" + name + "] AddManySelected", store.props());
+            var RemoveManySelected = store.createAction("[" + name + "] RemoveManySelected", store.props());
+            var RemoveAllSelected = store.createAction("[" + name + "] RemoveAllSelected");
+            var SelectItem = store.createAction("[" + name + "] SelectItem", store.props());
+            var Edit = store.createAction("[" + name + "] " + exports.CrudEnum.EDIT + " ", store.props());
+            var Create = store.createAction("[" + name + "] " + exports.CrudEnum.CREATE, store.props());
+            var Delete = store.createAction("[" + name + "] " + exports.CrudEnum.DELETE + " ", store.props());
+            return {
+                Response: Response,
+                ResetResponses: ResetResponses,
+                SearchRequest: SearchRequest,
+                SearchFailure: SearchFailure,
+                SearchSuccess: SearchSuccess,
+                DeleteRequest: DeleteRequest,
+                DeleteFailure: DeleteFailure,
+                DeleteSuccess: DeleteSuccess,
+                DeleteManyRequest: DeleteManyRequest,
+                DeleteManyFailure: DeleteManyFailure,
+                DeleteManySuccess: DeleteManySuccess,
+                CreateRequest: CreateRequest,
+                CreateFailure: CreateFailure,
+                CreateSuccess: CreateSuccess,
+                CreateManyRequest: CreateManyRequest,
+                CreateManyFailure: CreateManyFailure,
+                CreateManySuccess: CreateManySuccess,
+                SelectRequest: SelectRequest,
+                SelectFailure: SelectFailure,
+                SelectSuccess: SelectSuccess,
+                EditRequest: EditRequest,
+                EditFailure: EditFailure,
+                EditSuccess: EditSuccess,
+                EditManyRequest: EditManyRequest,
+                EditManyFailure: EditManyFailure,
+                EditManySuccess: EditManySuccess,
+                Reset: Reset,
+                Filters: Filters,
+                SelectItems: SelectItems,
+                RemoveManySelected: RemoveManySelected,
+                AddManySelected: AddManySelected,
+                RemoveAllSelected: RemoveAllSelected,
+                SelectItem: SelectItem,
+                Edit: Edit,
+                Create: Create,
+                Delete: Delete,
+            };
+        }
+        return { createCrudActions: createCrudActions };
+    }
+
+    /*! *****************************************************************************
+    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;
+    }
+
+    var ofFailure = function () {
+        return function (input$) { return input$.pipe(operators.filter(function (value) { return value.type.endsWith(exports.ActionEnum.FAILURE); })); };
+    };
+    function selectIdValue(entity, selectId) {
+        var key = selectId(entity);
+        if (i0.isDevMode() && key === undefined) {
+            console.warn('@ngrx/entity: The entity passed to the `selectId` implementation returned undefined.', 'You should probably provide your own `selectId` implementation.', 'The entity that was passed:', entity, 'The `selectId` implementation:', selectId.toString());
+        }
+        return key;
+    }
+    var toDictionary = function (items, adapter) { return items.reduce(function (prev, curr) {
+        var key = selectIdValue(curr, adapter.selectId);
+        prev[key] = curr;
+        return prev;
+    }, {}); };
+
+    function evalData(fn, def) {
+        if (def === void 0) { def = null; }
+        try {
+            return fn();
+        }
+        catch (e) {
+            return def;
+        }
+    }
+    function createCrudOns(adapter, initialState, actions) {
+        var searchRequestOn = store.on(actions.SearchRequest, function (state, criteria) {
+            if (!criteria.path && !criteria.mode && !criteria.queryParams) {
+                throw new Error('It is not possible a search without payload, use :\'{criteria:{}}\'');
+            }
+            var itemSelected = initialState.itemSelected, idSelected = initialState.idSelected, entitiesSelected = initialState.entitiesSelected, idsSelected = initialState.idsSelected;
+            if (criteria.mode === 'REFRESH' || criteria.mode === 'upsertMany') {
+                return Object.assign({}, state, {
+                    isLoading: true,
+                    error: initialState.error,
+                    lastCriteria: criteria,
+                    itemSelected: itemSelected,
+                    idSelected: idSelected,
+                    entitiesSelected: entitiesSelected,
+                    idsSelected: idsSelected
+                });
+            }
+            return adapter.removeAll(Object.assign({}, state, {
+                isLoading: true,
+                error: initialState.error,
+                lastCriteria: criteria,
+                itemSelected: itemSelected,
+                idSelected: idSelected,
+                entitiesSelected: entitiesSelected,
+                idsSelected: idsSelected
+            }));
+        });
+        var deleteRequestOn = store.on(actions.DeleteRequest, function (state, request) {
+            return Object.assign({}, state, { isLoading: true, error: initialState.error });
+        });
+        var deleteManyRequestOn = store.on(actions.DeleteManyRequest, function (state, request) {
+            return Object.assign({}, state, { isLoading: true, error: initialState.error });
+        });
+        var editRequestOn = store.on(actions.EditRequest, function (state, request) {
+            return Object.assign({}, state, { isLoading: true, error: initialState.error });
+        });
+        var editManyRequestOn = store.on(actions.EditManyRequest, function (state, request) {
+            return Object.assign({}, state, { isLoading: true, error: initialState.error });
+        });
+        var createRequestOn = store.on(actions.CreateRequest, function (state, request) {
+            return Object.assign({}, state, { isLoading: true, error: initialState.error });
+        });
+        var createManyRequestOn = store.on(actions.CreateManyRequest, function (state, request) {
+            return Object.assign({}, state, { isLoading: true, error: initialState.error });
+        });
+        var selectRequestOn = store.on(actions.SelectRequest, function (state, request) {
+            return Object.assign({}, state, { isLoading: true, error: initialState.error });
+        });
+        var searchSuccessOn = store.on(actions.SearchSuccess, function (state, _a) {
+            var type = _a.type, items = _a.items, request = _a.request;
+            var mode = evalData(function () { return request.mode; }, null) || 'setAll';
+            var method;
+            switch (mode) {
+                case 'REFRESH': {
+                    // console.log('REFRESH');
+                    method = adapter.setAll;
+                    break;
+                }
+                case 'upsertMany': {
+                    // console.log('upsertMany');
+                    method = adapter.upsertMany;
+                    break;
+                }
+                case 'setAll': {
+                    // console.log('setAll');
+                    method = adapter.setAll;
+                    break;
+                }
+                default: {
+                    // console.log('default');
+                    method = adapter.setAll;
+                    break;
+                }
+            }
+            return method(items, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null
+            }));
+        });
+        var deleteSuccessOn = store.on(actions.DeleteSuccess, function (state, _a) {
+            var type = _a.type, id = _a.id;
+            // tolgo dallo store.idsSelected l'elemento cancellato
+            var idsSelected = state.idsSelected.filter(function (idA) { return idA === id; });
+            var entitiesSelected = idsSelected.reduce(function (prev, curr) {
+                prev[curr] = state.entitiesSelected[curr];
+                return prev;
+            }, {});
+            // se ho cancellato l'id seezionato, lo tolgo dallo store.
+            var idSelected = !!state.idSelected && state.idSelected === id ? null : state.idSelected;
+            var itemSelected = !idSelected ? null : state.itemSelected;
+            return adapter.removeOne(id, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null,
+                idSelected: idSelected,
+                idsSelected: idsSelected,
+                itemSelected: itemSelected,
+                entitiesSelected: entitiesSelected
+            }));
+        });
+        var deleteManySuccessOn = store.on(actions.DeleteManySuccess, function (state, _a) {
+            var type = _a.type, ids = _a.ids;
+            // tolgo dallo store.idsSelected gli elementi che sono stati cancellati.
+            var idsSelected = state.idsSelected.filter(function (id) { return !(id in ids); });
+            var entitiesSelected = idsSelected.reduce(function (prev, curr) {
+                prev[curr] = state.entitiesSelected[curr];
+                return prev;
+            }, {});
+            // se ho cancellato l'id seezionato, lo tolgo dallo store.
+            var idSelected = !!state.idSelected && state.idSelected in ids ? null : state.idSelected;
+            var itemSelected = !idSelected ? null : state.itemSelected;
+            return adapter.removeMany(ids, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null,
+                idSelected: idSelected,
+                idsSelected: idsSelected,
+                itemSelected: itemSelected,
+                entitiesSelected: entitiesSelected
+            }));
+        });
+        var deleteOn = store.on(actions.Delete, function (state, _a) {
+            var type = _a.type, id = _a.id;
+            // tolgo dallo store.idsSelected l'elemento cancellato
+            var idsSelected = state.idsSelected.filter(function (idA) { return idA === id; });
+            // se ho cancellato l'id seezionato, lo tolgo dallo store.
+            var idSelected = !!state.idSelected && state.idSelected === id ? null : state.idSelected;
+            return adapter.removeOne(id, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null,
+                idSelected: idSelected,
+                idsSelected: idsSelected
+            }));
+        });
+        var responseOn = store.on(actions.Response, function (state, response) {
+            var responses = __spreadArray(__spreadArray([], __read(state.responses)), [response]);
+            return Object.assign(Object.assign({}, state), { responses: responses });
+        });
+        var resetResponsesOn = store.on(actions.ResetResponses, function (state) {
+            var responses = [];
+            return Object.assign(Object.assign({}, state), { responses: responses });
+        });
+        var createSuccessOn = store.on(actions.CreateSuccess, function (state, _a) {
+            var type = _a.type, item = _a.item;
+            return adapter.addOne(item, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null
+            }));
+        });
+        var createManySuccessOn = store.on(actions.CreateManySuccess, function (state, _a) {
+            var type = _a.type, items = _a.items;
+            return adapter.addMany(items, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null
+            }));
+        });
+        var createOn = store.on(actions.Create, function (state, _a) {
+            var type = _a.type, item = _a.item;
+            return adapter.addOne(item, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null
+            }));
+        });
+        var editSuccessOn = store.on(actions.EditSuccess, function (state, _a) {
+            var item = _a.item, type = _a.type;
+            return adapter.upsertOne(item, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null
+            }));
+        });
+        var editManySuccessOn = store.on(actions.EditManySuccess, function (state, _a) {
+            var items = _a.items, type = _a.type;
+            return adapter.upsertMany(items, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null
+            }));
+        });
+        var editOn = store.on(actions.Edit, function (state, _a) {
+            var item = _a.item, type = _a.type;
+            return adapter.upsertOne(item, Object.assign({}, state, {
+                isLoaded: true,
+                isLoading: false,
+                error: null
+            }));
+        });
+        var filtersOn = store.on(actions.Filters, function (state, _a) {
+            var type = _a.type, filters = _a.filters;
+            return Object.assign({}, state, { filters: filters });
+        });
+        var removeAllSelectedOn = store.on(actions.RemoveAllSelected, function (state, _a) {
+            var type = _a.type;
+            var result = Object.assign(Object.assign({}, state), { idsSelected: [],
+                // itemsSelected: [], //todo: @deprecated da cancellare questo tipo di assegnazione.
+                entitiesSelected: {} });
+            return result;
+        });
+        var addManySelectedOn = store.on(actions.AddManySelected, function (state, _a) {
+            var type = _a.type, items = _a.items;
+            var entitiesCurr = toDictionary(items, adapter);
+            var entitiesSelected = Object.assign(Object.assign({}, state.entitiesSelected), entitiesCurr);
+            var idsSelected = Object.keys(entitiesSelected);
+            var result = Object.assign(Object.assign({}, state), { idsSelected: idsSelected, 
+                // itemsSelected: items, //todo: @deprecated da cancellare questo tipo di assegnazione.
+                entitiesSelected: entitiesSelected });
+            return result;
+        });
+        var removeManySelectedOn = store.on(actions.RemoveManySelected, function (state, _a) {
+            var type = _a.type, ids = _a.ids;
+            var idsAsString = ids.map(function (x) { return x + ''; });
+            var idsSelected = Object.keys(state.entitiesSelected).filter(function (id) { return !idsAsString.includes(id + ''); });
+            var entitiesSelected = idsSelected.reduce(function (prec, curr) {
+                var _a;
+                return (Object.assign(Object.assign({}, prec), (_a = {}, _a[curr] = state.entitiesSelected[curr], _a)));
+            }, {});
+            // const itemsSelected = Object.values(entitiesSelected);
+            var result = Object.assign(Object.assign({}, state), { idsSelected: idsSelected, 
+                // itemsSelected, //todo: @deprecated da cancellare questo tipo di assegnazione.
+                entitiesSelected: entitiesSelected });
+            return result;
+        });
+        var selectItemsOn = store.on(actions.SelectItems, function (state, _a) {
+            var type = _a.type, items = _a.items;
+            var entitiesSelected = toDictionary(items, adapter);
+            var idsSelected = Object.keys(entitiesSelected);
+            var result = Object.assign(Object.assign({}, state), { idsSelected: idsSelected, 
+                // itemsSelected: items,
+                entitiesSelected: entitiesSelected });
+            return result;
+        });
+        var selectItemOn = store.on(actions.SelectItem, function (state, _a) {
+            var type = _a.type, item = _a.item;
+            var idSelected = selectIdValue(item, adapter.selectId);
+            var result = Object.assign(Object.assign({}, state), { idSelected: idSelected, itemSelected: item });
+            return result;
+        });
+        var selectSuccessOn = store.on(actions.SelectSuccess, function (state, _a) {
+            var type = _a.type, item = _a.item;
+            var idSelected = selectIdValue(item, adapter.selectId);
+            var result = Object.assign(Object.assign({}, state), { idSelected: idSelected, itemSelected: item, isLoaded: true, isLoading: false, error: null });
+            return result;
+        });
+        var searchFailureOn = store.on(actions.SearchFailure, function (state, _a) {
+            var type = _a.type, error = _a.error;
+            return Object.assign({}, state, {
+                isLoaded: false,
+                isLoading: false,
+                error: error
+            });
+        });
+        var deleteFailureOn = store.on(actions.DeleteFailure, function (state, _a) {
+            var type = _a.type, error = _a.error;
+            return Object.assign({}, state, {
+                isLoaded: false,
+                isLoading: false,
+                error: error
+            });
+        });
+        var deleteManyFailureOn = store.on(actions.DeleteManyFailure, function (state, _a) {
+            var type = _a.type, error = _a.error;
+            return Object.assign({}, state, {
+                isLoaded: false,
+                isLoading: false,
+                error: error
+            });
+        });
+        var createFailureOn = store.on(actions.CreateFailure, function (state, _a) {
+            var type = _a.type, error = _a.error;
+            return Object.assign({}, state, {
+                isLoaded: false,
+                isLoading: false,
+                error: error
+            });
+        });
+        var createManyFailureOn = store.on(actions.CreateManyFailure, function (state, _a) {
+            var type = _a.type, error = _a.error;
+            return Object.assign({}, state, {
+                isLoaded: false,
+                isLoading: false,
+                error: error
+            });
+        });
+        var editFailureOn = store.on(actions.EditFailure, function (state, _a) {
+            var error = _a.error, type = _a.type;
+            return Object.assign({}, state, {
+                isLoaded: false,
+                isLoading: false,
+                error: error
+            });
+        });
+        var editManyFailureOn = store.on(actions.EditManyFailure, function (state, _a) {
+            var error = _a.error, type = _a.type;
+            return Object.assign({}, state, {
+                isLoaded: false,
+                isLoading: false,
+                error: error
+            });
+        });
+        var selectFailureOn = store.on(actions.SelectFailure, function (state, _a) {
+            var error = _a.error, type = _a.type;
+            return Object.assign({}, state, {
+                isLoaded: false,
+                isLoading: false,
+                error: error
+            });
+        });
+        var resetOn = store.on(actions.Reset, function (state) { return (Object.assign(Object.assign({}, state), initialState)); });
+        return {
+            responseOn: responseOn,
+            resetResponsesOn: resetResponsesOn,
+            searchRequestOn: searchRequestOn,
+            deleteRequestOn: deleteRequestOn,
+            deleteManyRequestOn: deleteManyRequestOn,
+            editRequestOn: editRequestOn,
+            editManyRequestOn: editManyRequestOn,
+            createRequestOn: createRequestOn,
+            createManyRequestOn: createManyRequestOn,
+            selectRequestOn: selectRequestOn,
+            searchSuccessOn: searchSuccessOn,
+            deleteSuccessOn: deleteSuccessOn,
+            deleteManySuccessOn: deleteManySuccessOn,
+            createSuccessOn: createSuccessOn,
+            createManySuccessOn: createManySuccessOn,
+            selectSuccessOn: selectSuccessOn,
+            editSuccessOn: editSuccessOn,
+            editManySuccessOn: editManySuccessOn,
+            searchFailureOn: searchFailureOn,
+            deleteFailureOn: deleteFailureOn,
+            deleteManyFailureOn: deleteManyFailureOn,
+            createFailureOn: createFailureOn,
+            createManyFailureOn: createManyFailureOn,
+            selectFailureOn: selectFailureOn,
+            editFailureOn: editFailureOn,
+            editManyFailureOn: editManyFailureOn,
+            resetOn: resetOn,
+            filtersOn: filtersOn,
+            selectItemsOn: selectItemsOn,
+            removeAllSelectedOn: removeAllSelectedOn,
+            addManySelectedOn: addManySelectedOn,
+            removeManySelectedOn: removeManySelectedOn,
+            selectItemOn: selectItemOn,
+            editOn: editOn,
+            createOn: createOn,
+            deleteOn: deleteOn
+        };
+    }
+    function createCrudReducerFactory(adapter) {
+        function createCrudReducer(initialState, actions) {
+            var ons = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                ons[_i - 2] = arguments[_i];
+            }
+            var _a = createCrudOns(adapter, initialState, actions), responseOn = _a.responseOn, resetResponsesOn = _a.resetResponsesOn, searchRequestOn = _a.searchRequestOn, deleteRequestOn = _a.deleteRequestOn, deleteManyRequestOn = _a.deleteManyRequestOn, editRequestOn = _a.editRequestOn, editManyRequestOn = _a.editManyRequestOn, createRequestOn = _a.createRequestOn, createManyRequestOn = _a.createManyRequestOn, selectRequestOn = _a.selectRequestOn, searchSuccessOn = _a.searchSuccessOn, deleteSuccessOn = _a.deleteSuccessOn, deleteManySuccessOn = _a.deleteManySuccessOn, createSuccessOn = _a.createSuccessOn, createManySuccessOn = _a.createManySuccessOn, selectSuccessOn = _a.selectSuccessOn, editSuccessOn = _a.editSuccessOn, editManySuccessOn = _a.editManySuccessOn, searchFailureOn = _a.searchFailureOn, deleteFailureOn = _a.deleteFailureOn, deleteManyFailureOn = _a.deleteManyFailureOn, createFailureOn = _a.createFailureOn, createManyFailureOn = _a.createManyFailureOn, selectFailureOn = _a.selectFailureOn, editFailureOn = _a.editFailureOn, editManyFailureOn = _a.editManyFailureOn, resetOn = _a.resetOn, filtersOn = _a.filtersOn, selectItemsOn = _a.selectItemsOn, removeAllSelectedOn = _a.removeAllSelectedOn, addManySelectedOn = _a.addManySelectedOn, removeManySelectedOn = _a.removeManySelectedOn, selectItemOn = _a.selectItemOn, editOn = _a.editOn, createOn = _a.createOn, deleteOn = _a.deleteOn;
+            var totalOns = __spreadArray(__spreadArray([], __read(ons)), [
+                responseOn,
+                resetResponsesOn,
+                searchRequestOn,
+                deleteRequestOn,
+                deleteManyRequestOn,
+                editRequestOn,
+                editManyRequestOn,
+                createRequestOn,
+                createManyRequestOn,
+                selectRequestOn,
+                searchSuccessOn,
+                deleteSuccessOn,
+                deleteManySuccessOn,
+                createSuccessOn,
+                createManySuccessOn,
+                selectSuccessOn,
+                editSuccessOn,
+                editManySuccessOn,
+                searchFailureOn,
+                deleteFailureOn,
+                deleteManyFailureOn,
+                createFailureOn,
+                createManyFailureOn,
+                selectFailureOn,
+                editFailureOn,
+                editManyFailureOn,
+                resetOn,
+                filtersOn,
+                selectItemsOn,
+                removeAllSelectedOn,
+                addManySelectedOn,
+                removeManySelectedOn,
+                selectItemOn,
+                editOn,
+                createOn,
+                deleteOn
+            ]);
+            return store.createReducer.apply(void 0, __spreadArray([initialState], __read(totalOns)));
+        }
+        return {
+            createCrudReducer: createCrudReducer
+        };
+    }
+
+    function createCrudEntityAdapter(options) {
+        var adapter = entity.createEntityAdapter(options);
+        var stateFactory = createInitialCrudStateFactory();
+        var selectorsFactory = createCrudSelectorsFactory(adapter);
+        var actionsFactory = createCrudActionsFactory();
+        var reducerFactory = createCrudReducerFactory(adapter);
+        return Object.assign({}, adapter, stateFactory, selectorsFactory, actionsFactory, reducerFactory);
+    }
+
+    var searchCall = function (service) {
+        return function (input$) { return input$.pipe(operators.switchMap(function (payload) { return service.search(payload).pipe(operators.map(function (response) { return ({ response: response, payload: payload }); })); })); };
+    };
+    var searchResponse = function (actions, optEffect) {
+        return function (input$) { return input$.pipe(operators.switchMap(function (_a) {
+            var response = _a.response, payload = _a.payload;
+            var result = [];
+            if (response.hasError) {
+                result.push(actions.SearchFailure({ error: response.message }));
+                if (payload.onFault) {
+                    result.push.apply(result, __spreadArray([], __read(payload.onFault)));
+                }
+            }
+            else {
+                result.push(actions.SearchSuccess({ items: response.data, request: payload }));
+                result.push(actions.Filters({ filters: {} }));
+                if (payload.onResult) {
+                    var onResults = payload.onResult.map(function (a) { return a.newAction ? a.newAction(response, payload) : a; });
+                    result.push.apply(result, __spreadArray([], __read(onResults)));
+                }
+            }
+            if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+                result.push(actions.Response({
+                    actionType: payload.type,
+                    request: payload,
+                    response: response
+                }));
+            }
+            return result;
+        })); };
+    };
+    var searchCatchError = function (actions) {
+        return function (input$) { return input$.pipe(operators.catchError(function (error, caught) {
+            var response = [];
+            response.push(actions.SearchFailure({ error: error }));
+            response.push(actions.Response({
+                actionType: 'Failure',
+                request: null,
+                response: { hasError: true, message: error.message, data: null }
+            }));
+            return rxjs.from(response);
+        })); };
+    };
+    var searchRequest = function (actions, service, optEffect) {
+        return function (input$) { return input$.pipe(effects.ofType(actions.SearchRequest), searchCall(service), searchResponse(actions, optEffect), searchCatchError(actions), operators.repeat()); };
+    };
+    /**
+     * @deprecated use:
+     *
+     * actions$.pipe(
+     *   searchRequest(actions, service, clazz, optEffect)
+     * );
+     *
+     * or:
+     *
+     * actions$.pipe(
+     *  ofType(actions.SearchRequest),
+     *  searchCall(service),
+     *  searchResponse(actions, optEffect),
+     *  searchCatchError(actions),
+     *  repeat()
+     *  );
+     *
+     */
+    var searchRequestEffect = function (actions$, actions, service, optEffect) { return actions$.pipe(searchRequest(actions, service, optEffect)); };
+    var deleteCall = function (service) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (payload) { return service.delete(payload).pipe(operators.map(function (response) { return ({ response: response, payload: payload }); })); })); };
+    };
+    var deleteResponse = function (actions, clazz, optEffect) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (_a) {
+            var response = _a.response, payload = _a.payload;
+            var result = [];
+            if (response.hasError) {
+                result.push(actions.DeleteFailure({ error: response.message }));
+                if (payload.onFault) {
+                    result.push.apply(result, __spreadArray([], __read(payload.onFault)));
+                }
+            }
+            else {
+                if (!clazz.selectId) {
+                    throw Error('the selectId method is not present in the managed entity.');
+                }
+                var id = clazz.selectId(payload.mutationParams);
+                result.push(actions.DeleteSuccess({ id: id }));
+                if (payload.onResult) {
+                    var onResults = payload.onResult.map(function (a) { return a.newAction ? a.newAction(response, payload) : a; });
+                    result.push.apply(result, __spreadArray([], __read(onResults)));
+                }
+            }
+            if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+                result.push(actions.Response({
+                    actionType: payload.type,
+                    request: payload,
+                    response: response
+                }));
+            }
+            return result;
+        })); };
+    };
+    var deleteCatchError = function (actions) {
+        return function (input$) { return input$.pipe(operators.catchError(function (error, caught) {
+            var response = [];
+            response.push(actions.EditFailure({ error: error }));
+            response.push(actions.Response({
+                actionType: 'Failure',
+                request: null,
+                response: { hasError: true, message: error.message, data: null }
+            }));
+            return rxjs.from(response);
+        })); };
+    };
+    var deleteRequest = function (actions, service, clazz, optEffect) {
+        return function (input$) { return input$.pipe(effects.ofType(actions.DeleteRequest), deleteCall(service), deleteResponse(actions, clazz, optEffect), deleteCatchError(actions), operators.repeat()); };
+    };
+    /**
+     * @deprecated use:
+     *
+     * actions$.pipe(
+     *   deleteRequest(actions, service, clazz, optEffect)
+     * );
+     *
+     * or:
+     *
+     * actions$.pipe(
+     *  ofType(actions.DeleteRequest),
+     *  deleteCall(service),
+     *  deleteResponse(actions, clazz, optEffect),
+     *  deleteCatchError(actions),
+     *  repeat()
+     *  );
+     *
+     */
+    var deleteRequestEffect = function (actions$, actions, service, clazz, optEffect) { return actions$.pipe(deleteRequest(actions, service, clazz, optEffect)); };
+    var deleteManyCall = function (service) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (payload) { return service.deleteMany((payload)).pipe(operators.map(function (response) { return ({ response: response, payload: payload }); })); })); };
+    };
+    var deleteManyResponse = function (actions, clazz, optEffect) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (_a) {
+            var response = _a.response, payload = _a.payload;
+            var result = [];
+            if (response.hasError) {
+                result.push(actions.DeleteManyFailure({ error: response.message }));
+                if (payload.onFault) {
+                    result.push.apply(result, __spreadArray([], __read(payload.onFault)));
+                }
+            }
+            else {
+                if (!clazz.selectId) {
+                    throw Error('the selectId method is not present in the managed entity.');
+                }
+                var ids = payload.mutationParams.map(function (id) { return clazz.selectId(id); });
+                result.push(actions.DeleteManySuccess({ ids: ids }));
+                if (payload.onResult) {
+                    var onResults = payload.onResult.map(function (a) { return a.newAction ? a.newAction(response, payload) : a; });
+                    result.push.apply(result, __spreadArray([], __read(onResults)));
+                }
+            }
+            if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+                result.push(actions.Response({
+                    actionType: payload.type,
+                    request: payload,
+                    response: response
+                }));
+            }
+            return result;
+        })); };
+    };
+    var deleteManyCatchError = function (actions) {
+        return function (input$) { return input$.pipe(operators.catchError(function (error, caught) {
+            var response = [];
+            response.push(actions.DeleteManyFailure({ error: error }));
+            response.push(actions.Response({
+                actionType: 'Failure',
+                request: null,
+                response: { hasError: true, message: error.message, data: null }
+            }));
+            return rxjs.from(response);
+        })); };
+    };
+    var deleteManyRequest = function (actions, service, clazz, optEffect) {
+        return function (input$) { return input$.pipe(effects.ofType(actions.DeleteManyRequest), deleteManyCall(service), deleteManyResponse(actions, clazz, optEffect), deleteManyCatchError(actions), operators.repeat()); };
+    };
+    var createCall = function (service) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (payload) { return service.create(payload).pipe(operators.map(function (response) { return ({ response: response, payload: payload }); })); })); };
+    };
+    var createResponse = function (actions, optEffect) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (_a) {
+            var response = _a.response, payload = _a.payload;
+            var result = [];
+            if (response.hasError) {
+                result.push(actions.CreateFailure({ error: response.message }));
+                if (payload.onFault) {
+                    result.push.apply(result, __spreadArray([], __read(payload.onFault)));
+                }
+            }
+            else {
+                var item = response.data;
+                result.push(actions.CreateSuccess({ item: item }));
+                if (payload.onResult) {
+                    var onResults = payload.onResult.map(function (a) { return a.newAction ? a.newAction(response, payload) : a; });
+                    result.push.apply(result, __spreadArray([], __read(onResults)));
+                }
+            }
+            if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+                result.push(actions.Response({
+                    actionType: payload.type,
+                    request: payload,
+                    response: response
+                }));
+            }
+            return result;
+        })); };
+    };
+    var createCatchError = function (actions) {
+        return function (input$) { return input$.pipe(operators.catchError(function (error, caught) {
+            var response = [];
+            response.push(actions.CreateFailure({ error: error }));
+            response.push(actions.Response({
+                actionType: 'Failure',
+                request: null,
+                response: { hasError: true, message: error.message, data: null }
+            }));
+            return rxjs.from(response);
+        })); };
+    };
+    var createRequest = function (actions, service, optEffect) {
+        return function (input$) { return input$.pipe(effects.ofType(actions.CreateRequest), createCall(service), createResponse(actions, optEffect), createCatchError(actions), operators.repeat()); };
+    };
+    /**
+     * @deprecated use:
+     *
+     * actions$.pipe(
+     *   createRequest(actions, service, optEffect)
+     * );
+     *
+     * or:
+     *
+     * actions$.pipe(
+     *  ofType(actions.DeleteRequest),
+     *  createCall(service),
+     *  createResponse(actions, optEffect),
+     *  createCatchError(actions),
+     *  repeat()
+     *  );
+     *
+     */
+    var createRequestEffect = function (actions$, actions, service, optEffect) { return actions$.pipe(createRequest(actions, service, optEffect)); };
+    var createManyCall = function (service) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (payload) { return service.createMany(payload).pipe(operators.map(function (response) { return ({ response: response, payload: payload }); })); })); };
+    };
+    var createManyResponse = function (actions, optEffect) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (_a) {
+            var response = _a.response, payload = _a.payload;
+            var result = [];
+            if (response.hasError) {
+                result.push(actions.CreateManyFailure({ error: response.message }));
+                if (payload.onFault) {
+                    result.push.apply(result, __spreadArray([], __read(payload.onFault)));
+                }
+            }
+            else {
+                var items = response.data;
+                result.push(actions.CreateManySuccess({ items: items }));
+                if (payload.onResult) {
+                    var onResults = payload.onResult.map(function (a) { return a.newAction ? a.newAction(response, payload) : a; });
+                    result.push.apply(result, __spreadArray([], __read(onResults)));
+                }
+            }
+            if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+                result.push(actions.Response({
+                    actionType: payload.type,
+                    request: payload,
+                    response: response
+                }));
+            }
+            return result;
+        })); };
+    };
+    var createManyCatchError = function (actions) {
+        return function (input$) { return input$.pipe(operators.catchError(function (error, caught) {
+            var response = [];
+            response.push(actions.EditManyFailure({ error: error }));
+            response.push(actions.Response({
+                actionType: 'Failure',
+                request: null,
+                response: { hasError: true, message: error.message, data: null }
+            }));
+            return rxjs.from(response);
+        })); };
+    };
+    var createManyRequest = function (actions, service, optEffect) {
+        return function (input$) { return input$.pipe(effects.ofType(actions.CreateManyRequest), createManyCall(service), createManyResponse(actions, optEffect), createManyCatchError(actions), operators.repeat()); };
+    };
+    var editCall = function (service) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (payload) { return service.update(payload).pipe(operators.map(function (response) { return ({ response: response, payload: payload }); })); })); };
+    };
+    var editResponse = function (actions, optEffect) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (_a) {
+            var response = _a.response, payload = _a.payload;
+            var result = [];
+            if (response.hasError) {
+                result.push(actions.EditFailure({ error: response.message }));
+                if (payload.onFault) {
+                    result.push.apply(result, __spreadArray([], __read(payload.onFault)));
+                }
+            }
+            else {
+                var item = response.data;
+                result.push(actions.EditSuccess({ item: item }));
+                if (payload.onResult) {
+                    var onResults = payload.onResult.map(function (a) { return a.newAction ? a.newAction(response, payload) : a; });
+                    result.push.apply(result, __spreadArray([], __read(onResults)));
+                }
+            }
+            if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+                result.push(actions.Response({
+                    actionType: payload.type,
+                    request: payload,
+                    response: response
+                }));
+            }
+            return result;
+        })); };
+    };
+    var editCatchError = function (actions) {
+        return function (input$) { return input$.pipe(operators.catchError(function (error, caught) {
+            var response = [];
+            response.push(actions.EditFailure({ error: error }));
+            response.push(actions.Response({
+                actionType: 'Failure',
+                request: null,
+                response: { hasError: true, message: error.message, data: null }
+            }));
+            return rxjs.from(response);
+        })); };
+    };
+    var editRequest = function (actions, service, optEffect) {
+        return function (input$) { return input$.pipe(effects.ofType(actions.EditRequest), editCall(service), editResponse(actions, optEffect), editCatchError(actions), operators.repeat()); };
+    };
+    /**
+     * @deprecated use:
+     *
+     * actions$.pipe(
+     *   editRequest(actions, service, optEffect)
+     * );
+     *
+     * or:
+     *
+     * actions$.pipe(
+     *  ofType(actions.EditRequest),
+     *  editCall(service),
+     *  editResponse(actions, optEffect),
+     *  editCatchError(actions),
+     *  repeat()
+     *  );
+     *
+     */
+    var editRequestEffect = function (actions$, actions, service, optEffect) { return actions$.pipe(editRequest(actions, service, optEffect)); };
+    var editManyCall = function (service) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (payload) { return service.updateMany(payload).pipe(operators.map(function (response) { return ({ response: response, payload: payload }); })); })); };
+    };
+    var editManyResponse = function (actions, optEffect) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (_a) {
+            var response = _a.response, payload = _a.payload;
+            var result = [];
+            if (response.hasError) {
+                result.push(actions.EditManyFailure({ error: response.message }));
+                if (payload.onFault) {
+                    result.push.apply(result, __spreadArray([], __read(payload.onFault)));
+                }
+            }
+            else {
+                var items = response.data;
+                result.push(actions.EditManySuccess({ items: items }));
+                if (payload.onResult) {
+                    var onResults = payload.onResult.map(function (a) { return a.newAction ? a.newAction(response, payload) : a; });
+                    result.push.apply(result, __spreadArray([], __read(onResults)));
+                }
+            }
+            if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+                result.push(actions.Response({
+                    actionType: payload.type,
+                    request: payload,
+                    response: response
+                }));
+            }
+            return result;
+        })); };
+    };
+    var editManyCatchError = function (actions) {
+        return function (input$) { return input$.pipe(operators.catchError(function (error, caught) {
+            var response = [];
+            response.push(actions.EditManyFailure({ error: error }));
+            response.push(actions.Response({
+                actionType: 'Failure',
+                request: null,
+                response: { hasError: true, message: error.message, data: null }
+            }));
+            return rxjs.from(response);
+        })); };
+    };
+    var editManyRequest = function (actions, service, optEffect) {
+        return function (input$) { return input$.pipe(effects.ofType(actions.EditManyRequest), editManyCall(service), editManyResponse(actions, optEffect), editManyCatchError(actions), operators.repeat()); };
+    };
+    var selectCall = function (service) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (payload) { return service.select(payload).pipe(
+        // @ts-ignore
+        operators.map(function (response) { return ({ response: response, payload: payload }); })); })); };
+    };
+    var selectResponse = function (actions, optEffect) {
+        return function (input$) { return input$.pipe(operators.concatMap(function (_a) {
+            var response = _a.response, payload = _a.payload;
+            var result = [];
+            if (response.hasError) {
+                result.push(actions.SelectFailure({ error: response.message }));
+                if (payload.onFault) {
+                    result.push.apply(result, __spreadArray([], __read(payload.onFault)));
+                }
+            }
+            else {
+                var item = response.data;
+                result.push(actions.SelectSuccess({ item: item }));
+                if (payload.onResult) {
+                    var onResults = payload.onResult.map(function (a) { return a.newAction ? a.newAction(response, payload) : a; });
+                    result.push.apply(result, __spreadArray([], __read(onResults)));
+                }
+            }
+            if ((optEffect || {}).dispatchResponse || payload.dispatchResponse) {
+                result.push(actions.Response({
+                    actionType: payload.type,
+                    request: payload,
+                    response: response
+                }));
+            }
+            return result;
+        })); };
+    };
+    var selectCatchError = function (actions) {
+        return function (input$) { return input$.pipe(operators.catchError(function (error, caught) {
+            var response = [];
+            response.push(actions.EditFailure({ error: error }));
+            response.push(actions.Response({
+                actionType: 'Failure',
+                request: null,
+                response: { hasError: true, message: error.message, data: null }
+            }));
+            return rxjs.from(response);
+        })); };
+    };
+    var selectRequest = function (actions, service, optEffect) {
+        return function (input$) { return input$.pipe(effects.ofType(actions.SelectRequest), selectCall(service), selectResponse(actions, optEffect), selectCatchError(actions), operators.repeat()); };
+    };
+    /**
+     * @deprecated use:
+     *
+     * actions$.pipe(
+     *   selectRequest(actions, service, clazz, optEffect)
+     * );
+     *
+     * or:
+     *
+     * actions$.pipe(
+     *  ofType(actions.SelectRequest),
+     *  selectCall(service),
+     *  selectResponse(actions, optEffect),
+     *  selectCatchError(actions),
+     *  repeat()
+     *  );
+     *
+     */
+    var selectRequestEffect = function (actions$, actions, service, optEffect) { return actions$.pipe(selectRequest(actions, service, optEffect)); };
+
+    var BaseCrudService = /** @class */ (function () {
+        function BaseCrudService(http) {
+            var _this = this;
+            this.http = http;
+            this.service = '';
+            this.id = 'id';
+            this.debug = false;
+            this.httpOptions = function () {
+                return {
+                    headers: new i1.HttpHeaders({ 'Content-Type': 'application/json' })
+                };
+            };
+            this.searchMap = function (res) { return res; };
+            this.getId = function (value) { return value[_this.id]; };
+        }
+        BaseCrudService.prototype.debugMode = function () {
+            this.debug = true;
+        };
+        BaseCrudService.prototype.create = function (opt) {
+            if (typeof (console) !== 'undefined' && this.debug) {
+                console.log('%c BaseCrudService.create()', 'color: #777777');
+                console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+            }
+            var path = !!opt && !!opt.path ? opt.path : null;
+            return this.http.post("" + this.getUrl(path), opt.mutationParams, this.httpOptions());
+        };
+        BaseCrudService.prototype.createMany = function (opt) {
+            var _this = this;
+            this.checkOptRequest(opt);
+            var result = opt.mutationParams.map(function (mutationParams) {
+                var optB = Object.assign(Object.assign({}, opt), { mutationParams: mutationParams });
+                return _this.create(optB).pipe(operators.map(function (value) { return (Object.assign(Object.assign({}, value), { data: [value.data] })); }) // trasformo la singola risposta da {data:T} in {data:T[]}
+                );
+            });
+            return rxjs.of.apply(void 0, __spreadArray([], __read(result))).pipe(operators.mergeMap(function (value) { return value; }));
+        };
+        /**
+         * metodo introdotto per la verifica di OptRequest
+         * nella nuova versione è stato sostituito opt.item e opt.items con opt.mutationParams
+         * in modo da renderlo compatibile come nomenclatura a graphql
+         * @param opt
+         */
+        BaseCrudService.prototype.checkOptRequest = function (opt) {
+            if (opt && opt.hasOwnProperty('item') && !!opt.item) {
+                throw new Error('Error, in new versions of the library the "items" or "item" attribute have been replaced by "mutationParams". all project attributes must be renamed.');
+            }
+            if (opt && opt.hasOwnProperty('items') && !!opt.items) {
+                throw new Error('Error, in new versions of the library the "items" or "item" attribute have been replaced by "mutationParams". all project attributes must be renamed.');
+            }
+            return true;
+        };
+        BaseCrudService.prototype.search = function (value) {
+            if (typeof (console) !== 'undefined' && this.debug) {
+                console.log('BaseCrudService.search()');
+                console.log('Extended from: ' + this.constructor.name);
+            }
+            var url = value && value.hasOwnProperty('path') && !!value.path ? value.path.join('/') : '';
+            var httpOptions = this.httpOptions();
+            if (value && value.hasOwnProperty('queryParams') && !!value.queryParams) {
+                httpOptions = (Object.assign(Object.assign({}, httpOptions), { params: value.queryParams }));
+            }
+            return this.http.get(this.getUrl() + url, httpOptions).pipe(operators.map(this.searchMap));
+        };
+        BaseCrudService.prototype.select = function (opt) {
+            if (typeof (console) !== 'undefined' && this.debug) {
+                console.log('%c BaseCrudService.select()', 'color: #777777');
+                console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+            }
+            var id = this.getId(opt.queryParams);
+            var path = !!opt && !!opt.path ? opt.path : null;
+            return this
+                .http
+                .get(this.getUrl(path) + "/" + id, this.httpOptions());
+        };
+        BaseCrudService.prototype.update = function (opt) {
+            this.checkOptRequest(opt);
+            if (typeof (console) !== 'undefined' && this.debug) {
+                console.log('%c BaseCrudService.update()', 'color: #777777');
+                console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+            }
+            var id = this.getId(opt.mutationParams);
+            var path = !!opt && !!opt.path ? opt.path : null;
+            return this.http.put(this.getUrl(path) + "/" + id, opt.mutationParams, this.httpOptions());
+        };
+        BaseCrudService.prototype.updateMany = function (opt) {
+            var _this = this;
+            this.checkOptRequest(opt);
+            var result = opt.mutationParams.map(function (mutationParams) {
+                var optB = Object.assign(Object.assign({}, opt), { mutationParams: mutationParams });
+                return _this.update(optB).pipe(operators.map(function (value) { return (Object.assign(Object.assign({}, value), { data: [value.data] })); }) // trasformo la singola risposta da {data:T} in {data:T[]}
+                );
+            });
+            return rxjs.of.apply(void 0, __spreadArray([], __read(result))).pipe(operators.mergeMap(function (value) { return value; }));
+        };
+        BaseCrudService.prototype.delete = function (opt) {
+            this.checkOptRequest(opt);
+            if (typeof (console) !== 'undefined' && this.debug) {
+                console.log('%c BaseCrudService.delete()', 'color: #777777');
+                console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+            }
+            var id = this.getId(opt.mutationParams);
+            var path = !!opt && !!opt.path ? opt.path : null;
+            return this.http.delete(this.getUrl(path) + "/" + id, this.httpOptions());
+        };
+        BaseCrudService.prototype.deleteMany = function (opt) {
+            var _this = this;
+            this.checkOptRequest(opt);
+            var result = opt.mutationParams.map(function (mutationParams) {
+                var optB = Object.assign(Object.assign({}, opt), { mutationParams: mutationParams });
+                return _this.delete(optB);
+            });
+            return rxjs.of.apply(void 0, __spreadArray([], __read(result))).pipe(operators.mergeMap(function (value) { return value; }));
+        };
+        BaseCrudService.prototype.getUrl = function (path) {
+            var result = !!path ? this.service + "/" + path.join('/') : this.service;
+            if (typeof (console) !== 'undefined' && this.debug) {
+                console.log('%c BaseCrudService.getUrl(path?:string[]): string', 'color: #777777');
+                console.log('%c path: ' + path, 'color: #777777');
+                console.log('%c Extended from: ' + this.constructor.name, 'color: #777777');
+                console.log('%c result: ' + result, 'color: #777777');
+            }
+            return result;
+        };
+        return BaseCrudService;
+    }());
+    BaseCrudService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function BaseCrudService_Factory() { return new BaseCrudService(i0__namespace.ɵɵinject(i1__namespace.HttpClient)); }, token: BaseCrudService, providedIn: "root" });
+    BaseCrudService.decorators = [
+        { type: i0.Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    BaseCrudService.ctorParameters = function () { return [
+        { type: i1.HttpClient }
+    ]; };
+
+    var BaseCrudGqlService = /** @class */ (function () {
+        function BaseCrudGqlService() {
+        }
+        BaseCrudGqlService.prototype.search = function (value) {
+            return this.query(value);
+        };
+        BaseCrudGqlService.prototype.select = function (opt) {
+            return this.mutate(opt);
+        };
+        BaseCrudGqlService.prototype.create = function (opt) {
+            return this.mutate(opt);
+        };
+        BaseCrudGqlService.prototype.createMany = function (opt) {
+            return this.mutate(opt);
+        };
+        BaseCrudGqlService.prototype.update = function (opt) {
+            return this.mutate(opt);
+        };
+        BaseCrudGqlService.prototype.updateMany = function (opt) {
+            return this.mutate(opt);
+        };
+        BaseCrudGqlService.prototype.delete = function (opt) {
+            return this.mutate(opt);
+        };
+        BaseCrudGqlService.prototype.deleteMany = function (opt) {
+            return this.mutate(opt);
+        };
+        //todo tolgo tipizzazione  MutationOptions mutateMany(opt: OptRequest<MutationOptions>): Observable<Response<string[]>> {
+        BaseCrudGqlService.prototype.mutateMany = function (opt) {
+            return this.apollo.mutate(opt.mutationParams).pipe(operators.map(function (response) {
+                debugger;
+                return ({
+                    message: '',
+                    hasError: false,
+                    data: response.data.allCoins
+                });
+            }));
+        };
+        //todo tolgo tipizzazione  MutationOptions mutate(opt: OptRequest<MutationOptions>): Observable<Response<string[]>> {
+        BaseCrudGqlService.prototype.mutate = function (opt) {
+            return this.apollo.mutate(opt.mutationParams).pipe(operators.map(function (response) {
+                debugger;
+                return ({
+                    message: '',
+                    hasError: false,
+                    data: response.data.allCoins
+                });
+            }));
+        };
+        //todo tolgo tipizzazione QueryOptions query(value?: ICriteria<QueryOptions>): Observable<Response<T[]>> {
+        BaseCrudGqlService.prototype.query = function (value) {
+            console.log('CoinService.search()');
+            return this.apollo
+                .query(value.queryParams).pipe(operators.map(function (response) {
+                debugger;
+                return ({
+                    message: '',
+                    hasError: false,
+                    data: response.data.allCoins
+                });
+            }));
+        };
+        return BaseCrudGqlService;
+    }());
+    BaseCrudGqlService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function BaseCrudGqlService_Factory() { return new BaseCrudGqlService(); }, token: BaseCrudGqlService, providedIn: "root" });
+    BaseCrudGqlService.decorators = [
+        { type: i0.Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    exports.BaseCrudGqlService = BaseCrudGqlService;
+    exports.BaseCrudService = BaseCrudService;
+    exports.createCall = createCall;
+    exports.createCatchError = createCatchError;
+    exports.createCrudEntityAdapter = createCrudEntityAdapter;
+    exports.createCrudOns = createCrudOns;
+    exports.createManyCall = createManyCall;
+    exports.createManyCatchError = createManyCatchError;
+    exports.createManyRequest = createManyRequest;
+    exports.createManyResponse = createManyResponse;
+    exports.createRequest = createRequest;
+    exports.createRequestEffect = createRequestEffect;
+    exports.createResponse = createResponse;
+    exports.deleteCall = deleteCall;
+    exports.deleteCatchError = deleteCatchError;
+    exports.deleteManyCall = deleteManyCall;
+    exports.deleteManyCatchError = deleteManyCatchError;
+    exports.deleteManyRequest = deleteManyRequest;
+    exports.deleteManyResponse = deleteManyResponse;
+    exports.deleteRequest = deleteRequest;
+    exports.deleteRequestEffect = deleteRequestEffect;
+    exports.deleteResponse = deleteResponse;
+    exports.editCall = editCall;
+    exports.editCatchError = editCatchError;
+    exports.editManyCall = editManyCall;
+    exports.editManyCatchError = editManyCatchError;
+    exports.editManyRequest = editManyRequest;
+    exports.editManyResponse = editManyResponse;
+    exports.editRequest = editRequest;
+    exports.editRequestEffect = editRequestEffect;
+    exports.editResponse = editResponse;
+    exports.searchCall = searchCall;
+    exports.searchCatchError = searchCatchError;
+    exports.searchRequest = searchRequest;
+    exports.searchRequestEffect = searchRequestEffect;
+    exports.searchResponse = searchResponse;
+    exports.selectCall = selectCall;
+    exports.selectCatchError = selectCatchError;
+    exports.selectRequest = selectRequest;
+    exports.selectRequestEffect = selectRequestEffect;
+    exports.selectResponse = selectResponse;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=ngrx-entity-crud.umd.js.map