@ngrx-traits/common 12.2.0 → 13.0.0

package/crud-entities/crud-entities.model.d.ts

@@ -44,9 +44,7 @@ export declare type CrudEntitiesSelectors<Entity> = {
      * @param state
      * @param props
      */
-    selectEntitiesChangesList: (state: LoadEntitiesState<Entity> & CrudEntitiesState<Entity>, props: {
-        type: ChangeType;
-    }) => EntityChange<Entity>[];
+    selectEntitiesChangesList: (state: LoadEntitiesState<Entity> & CrudEntitiesState<Entity>) => EntityChange<Entity>[];
     /**
      * Returns the entities plus the kind of change,
      * filters redundant changes ideal for a batch update

package/entities-pagination/entities-pagination.model.d.ts

@@ -34,18 +34,11 @@ export declare type EntitiesPaginationActions = {
     clearEntitiesPagesCache: ActionCreator<string, () => TypedAction<string>>;
 };
 export declare type EntitiesPaginationSelectors<T> = {
-    isEntitiesPageInCache: (state: LoadEntitiesState<T> & EntitiesPaginationState, props?: {
-        page?: number;
-    }) => boolean;
-    selectPageEntitiesList: (state: LoadEntitiesState<T> & EntitiesPaginationState, props?: {
-        page?: number;
-    }) => T[];
-    selectEntitiesPage: (state: LoadEntitiesState<T> & EntitiesPaginationState, props?: {
-        page?: number;
-    }) => PageModel<T>;
+    selectEntitiesCurrentPageList: (state: LoadEntitiesState<T> & EntitiesPaginationState) => T[];
+    selectEntitiesCurrentPage: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PageModel<T>;
     selectEntitiesPagedRequest: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PagedRequest;
-    selectEntitiesPageInfo: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PageInfoModel;
-    isLoadingEntitiesPage: (state: LoadEntitiesState<T> & EntitiesPaginationState) => boolean;
+    selectEntitiesCurrentPageInfo: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PageInfoModel;
+    isLoadingEntitiesCurrentPage: (state: LoadEntitiesState<T> & EntitiesPaginationState) => boolean;
 };
 export declare type EntitiesPaginationMutators<T> = {
     mergePaginatedEntities<S extends LoadEntitiesState<T> & EntitiesPaginationState>(entities: T[], total: number | undefined, state: S): S;
@@ -55,6 +48,10 @@ export interface PageModel<T> {
     pageIndex: number;
     total: number | undefined;
     pageSize: number;
+    pagesCount: number | undefined;
+    hasPrevious: boolean;
+    hasNext: boolean;
+    cacheType: CacheType;
 }
 export interface PageInfoModel {
     pageIndex: number;

package/entities-pagination/entities-pagination.model.internal.d.ts

@@ -1,5 +1,6 @@
 import { ActionCreator, TypedAction } from '@ngrx/store/src/models';
-import { EntitiesPaginationActions } from './entities-pagination.model';
+import { EntitiesPaginationActions, EntitiesPaginationSelectors, EntitiesPaginationState } from './entities-pagination.model';
+import { LoadEntitiesState } from '../load-entities/load-entities.model';
 /**
  * @internal
  */
@@ -10,3 +11,10 @@ export declare type ƟPaginationActions = EntitiesPaginationActions & {
         index: number;
     } & TypedAction<string>>;
 };
+/**
+ * @internal
+ */
+export declare type ƟEntitiesPaginationSelectors<Entity> = EntitiesPaginationSelectors<Entity> & {
+    isEntitiesCurrentPageInCache: (state: LoadEntitiesState<Entity> & EntitiesPaginationState) => boolean;
+    isEntitiesNextPageInCache: (state: LoadEntitiesState<Entity> & EntitiesPaginationState) => boolean;
+};

package/entities-pagination/entities-pagination.trait.d.ts

@@ -57,13 +57,12 @@ import { EntitiesPaginationConfig, EntitiesPaginationSelectors } from './entitie
  * traits.actions.loadTodosLastPage()
  * traits.actions.clearTodosPagesCache()
  * // generated selectors
- * traits.selectors.isTodosPageInCache()
- * traits.selectors.selectPageTodosList()
- * traits.selectors.isLoadingTodosPage()
+ * traits.selectors.selectTodosCurrentPageList()
+ * traits.selectors.isLoadingTodosCurrentPage()
  * // use isLoadingTodosPage over isLoadingTodos (which will return true even
  * // if the page loading is not the current one)
- * traits.selectors.selectTodosPage()
+ * traits.selectors.selectTodosCurrentPage()
  * traits.selectors.selectTodosPagedRequest()// use in effects to get paging parameter
- * traits.selectors.selectTodosPageInfo()
+ * traits.selectors.selectTodosCurrentPageInfo()
  */
 export declare function addEntitiesPaginationTrait<Entity>({ cacheType, pageSize, currentPage, pagesToCache, }?: EntitiesPaginationConfig): import("@ngrx-traits/core").TraitFactory<import("../load-entities/load-entities.model").LoadEntitiesState<Entity> & import("./entities-pagination.model").EntitiesPaginationState, import("./entities-pagination.model").EntitiesPaginationActions, EntitiesPaginationSelectors<Entity>, {}, "pagination", EntitiesPaginationConfig, import("@ngrx-traits/core").AllTraitConfigs>;

package/esm2020/async-action/async-action.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXN5bmMtYWN0aW9uLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZ3J4LXRyYWl0cy9jb21tb24vc3JjL2xpYi9hc3luYy1hY3Rpb24vYXN5bmMtYWN0aW9uLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQb3N0Zml4UHJvcHMsIFByZWZpeFByb3BzIH0gZnJvbSAnQG5ncngtdHJhaXRzL2NvcmUnO1xuaW1wb3J0IHsgQWN0aW9uQ3JlYXRvciwgTm90QWxsb3dlZENoZWNrIH0gZnJvbSAnQG5ncngvc3RvcmUnO1xuaW1wb3J0IHsgVHlwZWRBY3Rpb24gfSBmcm9tICdAbmdyeC9zdG9yZS9zcmMvbW9kZWxzJztcbmltcG9ydCB7IFN0YXR1c1N0YXRlIH0gZnJvbSAnLi4vbG9hZC1lbnRpdGllcyc7XG5cbmV4cG9ydCB0eXBlIEFjdGlvbkNyZWF0b3JXaXRoT3B0aW9uYWxQcm9wczxUPiA9IFQgZXh0ZW5kcyB1bmRlZmluZWRcbiAgPyBBY3Rpb25DcmVhdG9yPHN0cmluZywgKCkgPT4gVHlwZWRBY3Rpb248c3RyaW5nPj5cbiAgOiBBY3Rpb25DcmVhdG9yPFxuICAgICAgc3RyaW5nLFxuICAgICAgKHByb3BzOiBUICYgTm90QWxsb3dlZENoZWNrPFQgJiBvYmplY3Q+KSA9PiBUICYgVHlwZWRBY3Rpb248c3RyaW5nPlxuICAgID47XG5cbnR5cGUgQXN5bmNBY3Rpb25zPFJlcXVlc3QsIFJlc3BvbnNlLCBGYWlsdXJlPiA9IHtcbiAgJyc6IEFjdGlvbkNyZWF0b3JXaXRoT3B0aW9uYWxQcm9wczxSZXF1ZXN0PjtcbiAgU3VjY2VzczogQWN0aW9uQ3JlYXRvcldpdGhPcHRpb25hbFByb3BzPFJlc3BvbnNlPjtcbiAgRmFpbDogQWN0aW9uQ3JlYXRvcldpdGhPcHRpb25hbFByb3BzPEZhaWx1cmU+O1xufTtcblxudHlwZSBTdGF0dXNTZWxlY3RvcnM8UyBleHRlbmRzIFN0YXR1c1N0YXRlPiA9IHtcbiAgaXNMb2FkaW5nOiAoc3RhdGU6IFMpID0+IGJvb2xlYW47XG4gIGlzU3VjY2VzczogKHN0YXRlOiBTKSA9PiBib29sZWFuO1xuICBpc0ZhaWw6IChzdGF0ZTogUykgPT4gYm9vbGVhbjtcbn07XG5cbmV4cG9ydCB0eXBlIEFzeW5jQWN0aW9uU3RhdGU8SiBleHRlbmRzIHN0cmluZz4gPSBQcmVmaXhQcm9wczxTdGF0dXNTdGF0ZSwgSj47XG5cbmV4cG9ydCB0eXBlIEFzeW5jQWN0aW9uU2VsZWN0b3JzPEogZXh0ZW5kcyBzdHJpbmcsIFM+ID0gUG9zdGZpeFByb3BzPFxuICBTdGF0dXNTZWxlY3RvcnM8Uz4sXG4gIEpcbj47XG5cbmV4cG9ydCB0eXBlIEFzeW5jQWN0aW9uQWN0aW9uczxcbiAgUmVxdWVzdCxcbiAgUmVzcG9uc2UsXG4gIEZhaWx1cmUsXG4gIEogZXh0ZW5kcyBzdHJpbmdcbj4gPSBQcmVmaXhQcm9wczxBc3luY0FjdGlvbnM8UmVxdWVzdCwgUmVzcG9uc2UsIEZhaWx1cmU+LCBKPjtcbiJdfQ==

package/esm2020/async-action/async-action.trait.mjs

@@ -0,0 +1,110 @@
+import { createAction, createReducer, on } from '@ngrx/store';
+import { camelCaseToSentence, createTraitFactory } from '@ngrx-traits/core';
+/**
+ * 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. This trait can be added more thant once as long
+ * as the name prop is different.
+ *
+ * @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',
+ *      ),
+ *    });
+ * //   adds following props to the state:
+ * //    createClientStatus?: 'loading' | 'success' | 'fail';
+ *
+ * // generated actions
+ * traits.actions.createClient({name:'Pedro'})
+ * traits.actions.createClientSuccess({id:'123'})
+ * traits.actions.createClientFail();
+ * //generated selectors
+ * traits.selectors.isLoadingCreateClient
+ * traits.selectors.isSuccessCreateClient
+ * traits.selectors.isFailCreateClient
+ */
+export function addAsyncActionTrait({ name, actionProps, actionSuccessProps, actionFailProps, }) {
+    const nameAsSentence = camelCaseToSentence(name);
+    let internalActions;
+    return createTraitFactory({
+        key: name + '-call',
+        config: {
+            name,
+            actionProps,
+            actionSuccessProps,
+            actionFailProps,
+        },
+        actions: ({ actionsGroupKey, }) => {
+            internalActions = {
+                request: (actionProps
+                    ? createAction(`${actionsGroupKey} ${nameAsSentence}`, actionProps)
+                    : createAction(`${actionsGroupKey} ${nameAsSentence}`)),
+                requestSuccess: (actionSuccessProps
+                    ? createAction(`${actionsGroupKey} ${nameAsSentence} Success`, actionSuccessProps)
+                    : createAction(`${actionsGroupKey} ${nameAsSentence} Success`)),
+                requestFail: (actionFailProps
+                    ? createAction(`${actionsGroupKey} ${nameAsSentence} Failure`, actionFailProps)
+                    : createAction(`${actionsGroupKey} ${nameAsSentence} Failure`)),
+            };
+            if (name) {
+                return {
+                    [`${name}`]: internalActions.request,
+                    [`${name}Success`]: internalActions.requestSuccess,
+                    [`${name}Fail`]: internalActions.requestFail,
+                };
+            }
+            return internalActions;
+        },
+        selectors: () => {
+            function isLoadingEntity(state) {
+                return state[`${name}Status`] === 'loading';
+            }
+            function isSuccessEntity(state) {
+                return state[`${name}Status`] === 'success';
+            }
+            function isFailEntity(state) {
+                return state[`${name}Status`] === 'fail';
+            }
+            const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+            return {
+                [`isLoading${capitalizedName}`]: isLoadingEntity,
+                [`isSuccess${capitalizedName}`]: isSuccessEntity,
+                [`isFail${capitalizedName}`]: isFailEntity,
+            };
+        },
+        initialState: ({ previousInitialState }) => previousInitialState,
+        reducer: ({ initialState }) => {
+            return createReducer(initialState, on(internalActions.request, (state) => ({
+                ...state,
+                [`${name}Status`]: 'loading',
+            })), on(internalActions.requestFail, (state) => ({
+                ...state,
+                [`${name}Status`]: 'fail',
+            })), on(internalActions.requestSuccess, (state) => ({
+                ...state,
+                [`${name}Status`]: 'success',
+            })));
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-action.trait.js","sourceRoot":"","sources":["../../../../../../libs/ngrx-traits/common/src/lib/async-action/async-action.trait.ts"],"names":[],"mappings":"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","sourcesContent":["import { createAction, createReducer, on } from '@ngrx/store';\nimport { ActionCreatorProps } from '@ngrx/store/src/models';\nimport { camelCaseToSentence, createTraitFactory } from '@ngrx-traits/core';\nimport {\n  ActionCreatorWithOptionalProps,\n  AsyncActionActions,\n  AsyncActionSelectors,\n  AsyncActionState,\n} from './async-action.model';\nimport {\n  TraitActionsFactoryConfig,\n  TraitInitialStateFactoryConfig,\n} from '@ngrx-traits/core';\n\n/**\n * Generates the typical ngrx code need to make a async action with\n * a request, success and failure actions, plus a status property to track its progress\n * and selectors to query the status. This trait can be added more thant once as long\n * as the name prop is different.\n *\n * @param options - Config object for the trait factory\n * @param options.name - Name of the main request action, should be in camel case\n * @param options.actionProps - Optional param for the main request action, use the props()\n * function for its value, if not present action will have no params,\n * @param options.actionSuccessProps - Optional param for the request success action,\n * use the props() function for its value, if not present action success will have no params\n * @param options.actionFailProps - Optional param for the request fail action,\n * use the props() function for its value, if not present action fail will have no params\n * @returns the trait factory\n *\n * @example\n * // The following trait config\n * const traits = createEntityFeatureFactory(\n * {entityName: 'Todo'},\n * addAsyncActionTrait({\n *        name: 'createClient',\n *        actionProps: props<{ name: string }>(),\n *        actionSuccessProps: props<{ id: string }>(),\n *      }),\n * )({\n *      actionsGroupKey: 'Client',\n *      featureSelector: createFeatureSelector<AsyncActionState<'createClient'>>(\n *        'client',\n *      ),\n *    });\n * //   adds following props to the state:\n * //    createClientStatus?: 'loading' | 'success' | 'fail';\n *\n * // generated actions\n * traits.actions.createClient({name:'Pedro'})\n * traits.actions.createClientSuccess({id:'123'})\n * traits.actions.createClientFail();\n * //generated selectors\n * traits.selectors.isLoadingCreateClient\n * traits.selectors.isSuccessCreateClient\n * traits.selectors.isFailCreateClient\n */\nexport function addAsyncActionTrait<\n  J extends string,\n  Request extends object | undefined = undefined,\n  Response extends object | undefined = undefined,\n  Failure extends object | undefined = undefined\n>({\n  name,\n  actionProps,\n  actionSuccessProps,\n  actionFailProps,\n}: {\n  name: J;\n  actionProps?: ActionCreatorProps<Request>;\n  actionSuccessProps?: ActionCreatorProps<Response>;\n  actionFailProps?: ActionCreatorProps<Failure>;\n}) {\n  const nameAsSentence = camelCaseToSentence(name);\n\n  let internalActions: AsyncActionActions<\n    Request,\n    Response,\n    Failure,\n    'request'\n  >;\n  return createTraitFactory({\n    key: name + '-call',\n    config: {\n      name,\n      actionProps,\n      actionSuccessProps,\n      actionFailProps,\n    },\n    actions: ({\n      actionsGroupKey,\n    }: TraitActionsFactoryConfig): AsyncActionActions<\n      Request,\n      Response,\n      Failure,\n      J\n    > => {\n      internalActions = {\n        request: (actionProps\n          ? createAction(\n              `${actionsGroupKey} ${nameAsSentence}`,\n              actionProps as any\n            )\n          : createAction(\n              `${actionsGroupKey} ${nameAsSentence}`\n            )) as ActionCreatorWithOptionalProps<Request>,\n        requestSuccess: (actionSuccessProps\n          ? createAction(\n              `${actionsGroupKey} ${nameAsSentence} Success`,\n              actionSuccessProps as any\n            )\n          : createAction(\n              `${actionsGroupKey} ${nameAsSentence} Success`\n            )) as ActionCreatorWithOptionalProps<Response>,\n        requestFail: (actionFailProps\n          ? createAction(\n              `${actionsGroupKey} ${nameAsSentence} Failure`,\n              actionFailProps as any\n            )\n          : createAction(\n              `${actionsGroupKey} ${nameAsSentence} Failure`\n            )) as ActionCreatorWithOptionalProps<Failure>,\n      };\n      if (name) {\n        return {\n          [`${name}`]: internalActions.request,\n          [`${name}Success`]: internalActions.requestSuccess,\n          [`${name}Fail`]: internalActions.requestFail,\n        } as AsyncActionActions<Request, Response, Failure, J>;\n      }\n      return internalActions;\n    },\n    selectors: () => {\n      function isLoadingEntity<S extends AsyncActionState<J>>(state: S) {\n        return (state as any)[`${name}Status`] === 'loading';\n      }\n      function isSuccessEntity<S extends AsyncActionState<J>>(state: S) {\n        return (state as any)[`${name}Status`] === 'success';\n      }\n      function isFailEntity<S extends AsyncActionState<J>>(state: S) {\n        return (state as any)[`${name}Status`] === 'fail';\n      }\n      const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);\n      return {\n        [`isLoading${capitalizedName}`]: isLoadingEntity,\n        [`isSuccess${capitalizedName}`]: isSuccessEntity,\n        [`isFail${capitalizedName}`]: isFailEntity,\n      } as AsyncActionSelectors<J, AsyncActionState<J>>;\n    },\n    initialState: ({ previousInitialState }: TraitInitialStateFactoryConfig) =>\n      previousInitialState as AsyncActionState<J>,\n    reducer: ({ initialState }) => {\n      return createReducer(\n        initialState,\n        on(\n          internalActions.request,\n          (state) =>\n            ({\n              ...state,\n              [`${name}Status`]: 'loading',\n            } as AsyncActionState<J>)\n        ),\n        on(\n          internalActions.requestFail,\n          (state) =>\n            ({\n              ...state,\n              [`${name}Status`]: 'fail',\n            } as AsyncActionState<J>)\n        ),\n        on(\n          internalActions.requestSuccess,\n          (state) =>\n            ({\n              ...state,\n              [`${name}Status`]: 'success',\n            } as AsyncActionState<J>)\n        )\n      );\n    },\n  });\n}\n"]}

package/esm2020/async-action/index.mjs

@@ -0,0 +1,3 @@
+export * from './async-action.model';
+export * from './async-action.trait';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25ncngtdHJhaXRzL2NvbW1vbi9zcmMvbGliL2FzeW5jLWFjdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FzeW5jLWFjdGlvbi5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL2FzeW5jLWFjdGlvbi50cmFpdCc7XG4iXX0=

package/esm2020/crud-entities/crud-entities.model.mjs

@@ -0,0 +1,8 @@
+export var ChangeType;
+(function (ChangeType) {
+    ChangeType["CREATED"] = "c";
+    ChangeType["UPDATED"] = "u";
+    ChangeType["DELETED"] = "d";
+})(ChangeType || (ChangeType = {}));
+export const crudEntitiesTraitKey = 'crud';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/crud-entities/crud-entities.trait.actions.mjs

@@ -0,0 +1,20 @@
+import { createAction } from '@ngrx/store';
+export function createCrudTraitActions(actionsGroupKey, entitiesName) {
+    return {
+        addEntities: createAction(`${actionsGroupKey} Add ${entitiesName}`, (...entities) => ({
+            entities,
+        })),
+        removeEntities: createAction(`${actionsGroupKey} Remove ${entitiesName}`, (...keys) => ({
+            keys,
+        })),
+        updateEntities: createAction(`${actionsGroupKey} Update ${entitiesName}`, (...updates) => ({
+            updates,
+        })),
+        upsertEntities: createAction(`${actionsGroupKey} Upsert ${entitiesName}`, (...entities) => ({
+            entities,
+        })),
+        removeAllEntities: createAction(`${actionsGroupKey} Remove All ${entitiesName}`, (predicate) => ({ predicate })),
+        clearEntitiesChanges: createAction(`${actionsGroupKey} Clear  ${entitiesName} Changes`),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/crud-entities/crud-entities.trait.mjs

@@ -0,0 +1,57 @@
+import { createTraitFactory, } from '@ngrx-traits/core';
+import { createCrudTraitActions } from './crud-entities.trait.actions';
+import { createCrudTraitSelectors } from './crud-entities.trait.selectors';
+import { createCrudInitialState, createCrudTraitReducer, } from './crud-entities.trait.reducer';
+import { crudEntitiesTraitKey, } from './crud-entities.model';
+import { loadEntitiesTraitKey, } from '../load-entities/load-entities.model';
+import { createCrudTraitMutators } from './crud-entities.trait.mutators';
+/**
+ * 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',
+ *      ),
+ *    });
+ *
+ * //   adds following props to the state:
+ * //    changes: Change<Todo>[];
+ *
+ * // generated actions
+ * 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()
+ * // generated selectors
+ * traits.selectors.selectTodosChangesList()
+ * traits.selectors.selectFilteredTodosChangesList()
+ * traits.selectors.selectAllFilteredChanges()
+ */
+export function addCrudEntitiesTrait({ storeChanges = false, } = {}) {
+    return createTraitFactory({
+        key: crudEntitiesTraitKey,
+        depends: [loadEntitiesTraitKey],
+        config: { storeChanges },
+        actions: ({ actionsGroupKey, entitiesName }) => createCrudTraitActions(actionsGroupKey, entitiesName),
+        selectors: ({ previousSelectors }) => createCrudTraitSelectors(previousSelectors),
+        mutators: ({ allConfigs }) => createCrudTraitMutators(allConfigs),
+        initialState: ({ previousInitialState }) => createCrudInitialState(previousInitialState),
+        reducer: ({ initialState, allActions, allMutators, allConfigs }) => createCrudTraitReducer(initialState, allActions, allMutators, allConfigs),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3J1ZC1lbnRpdGllcy50cmFpdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmdyeC10cmFpdHMvY29tbW9uL3NyYy9saWIvY3J1ZC1lbnRpdGllcy9jcnVkLWVudGl0aWVzLnRyYWl0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxrQkFBa0IsR0FLbkIsTUFBTSxtQkFBbUIsQ0FBQztBQUMzQixPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN2RSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMzRSxPQUFPLEVBQ0wsc0JBQXNCLEVBQ3RCLHNCQUFzQixHQUN2QixNQUFNLCtCQUErQixDQUFDO0FBS3ZDLE9BQU8sRUFJTCxvQkFBb0IsR0FDckIsTUFBTSx1QkFBdUIsQ0FBQztBQUsvQixPQUFPLEVBSUwsb0JBQW9CLEdBQ3JCLE1BQU0sc0NBQXNDLENBQUM7QUFLOUMsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFekU7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW9DRztBQUNILE1BQU0sVUFBVSxvQkFBb0IsQ0FBUyxFQUMzQyxZQUFZLEdBQUcsS0FBSyxNQUNFLEVBQUU7SUFDeEIsT0FBTyxrQkFBa0IsQ0FBQztRQUN4QixHQUFHLEVBQUUsb0JBQW9CO1FBQ3pCLE9BQU8sRUFBRSxDQUFDLG9CQUFvQixDQUFDO1FBQy9CLE1BQU0sRUFBRSxFQUFFLFlBQVksRUFBd0I7UUFDOUMsT0FBTyxFQUFFLENBQUMsRUFBRSxlQUFlLEVBQUUsWUFBWSxFQUE2QixFQUFFLEVBQUUsQ0FDeEUsc0JBQXNCLENBQVMsZUFBZSxFQUFFLFlBQVksQ0FBQztRQUMvRCxTQUFTLEVBQUUsQ0FBQyxFQUFFLGlCQUFpQixFQUErQixFQUFFLEVBQUUsQ0FDaEUsd0JBQXdCLENBQ3RCLGlCQUFrRCxDQUNuRDtRQUNILFFBQVEsRUFBRSxDQUFDLEVBQUUsVUFBVSxFQUFtQyxFQUFFLEVBQUUsQ0FDNUQsdUJBQXVCLENBQ3JCLFVBQXVFLENBQ3hFO1FBQ0gsWUFBWSxFQUFFLENBQUMsRUFBRSxvQkFBb0IsRUFBa0MsRUFBRSxFQUFFLENBQ3pFLHNCQUFzQixDQUFTLG9CQUFvQixDQUFDO1FBQ3RELE9BQU8sRUFBRSxDQUFDLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLEVBQUUsRUFBRSxDQUNqRSxzQkFBc0IsQ0FDcEIsWUFBWSxFQUNaLFVBSTJCLEVBQzNCLFdBQVcsRUFDWCxVQUkrQixDQUNoQztLQUNKLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBjcmVhdGVUcmFpdEZhY3RvcnksXG4gIFRyYWl0QWN0aW9uc0ZhY3RvcnlDb25maWcsXG4gIFRyYWl0SW5pdGlhbFN0YXRlRmFjdG9yeUNvbmZpZyxcbiAgVHJhaXRTZWxlY3RvcnNGYWN0b3J5Q29uZmlnLFxuICBUcmFpdFN0YXRlTXV0YXRvcnNGYWN0b3J5Q29uZmlnLFxufSBmcm9tICdAbmdyeC10cmFpdHMvY29yZSc7XG5pbXBvcnQgeyBjcmVhdGVDcnVkVHJhaXRBY3Rpb25zIH0gZnJvbSAnLi9jcnVkLWVudGl0aWVzLnRyYWl0LmFjdGlvbnMnO1xuaW1wb3J0IHsgY3JlYXRlQ3J1ZFRyYWl0U2VsZWN0b3JzIH0gZnJvbSAnLi9jcnVkLWVudGl0aWVzLnRyYWl0LnNlbGVjdG9ycyc7XG5pbXBvcnQge1xuICBjcmVhdGVDcnVkSW5pdGlhbFN0YXRlLFxuICBjcmVhdGVDcnVkVHJhaXRSZWR1Y2VyLFxufSBmcm9tICcuL2NydWQtZW50aXRpZXMudHJhaXQucmVkdWNlcic7XG5pbXBvcnQge1xuICBTb3J0RW50aXRpZXNBY3Rpb25zLFxuICBTb3J0RW50aXRpZXNLZXllZENvbmZpZyxcbn0gZnJvbSAnLi4vc29ydC1lbnRpdGllcy9zb3J0LWVudGl0aWVzLm1vZGVsJztcbmltcG9ydCB7XG4gIENydWRFbnRpdGllc0FjdGlvbnMsXG4gIENydWRFbnRpdGllc0NvbmZpZyxcbiAgQ3J1ZEVudGl0aWVzS2V5ZWRDb25maWcsXG4gIGNydWRFbnRpdGllc1RyYWl0S2V5LFxufSBmcm9tICcuL2NydWQtZW50aXRpZXMubW9kZWwnO1xuaW1wb3J0IHtcbiAgRmlsdGVyRW50aXRpZXNBY3Rpb25zLFxuICBGaWx0ZXJFbnRpdGllc0tleWVkQ29uZmlnLFxufSBmcm9tICcuLi9maWx0ZXItZW50aXRpZXMvZmlsdGVyLWVudGl0aWVzLm1vZGVsJztcbmltcG9ydCB7XG4gIExvYWRFbnRpdGllc0FjdGlvbnMsXG4gIExvYWRFbnRpdGllc0tleWVkQ29uZmlnLFxuICBMb2FkRW50aXRpZXNTZWxlY3RvcnMsXG4gIGxvYWRFbnRpdGllc1RyYWl0S2V5LFxufSBmcm9tICcuLi9sb2FkLWVudGl0aWVzL2xvYWQtZW50aXRpZXMubW9kZWwnO1xuaW1wb3J0IHtcbiAgRW50aXRpZXNQYWdpbmF0aW9uQWN0aW9ucyxcbiAgRW50aXRpZXNQYWdpbmF0aW9uS2V5ZWRDb25maWcsXG59IGZyb20gJy4uL2VudGl0aWVzLXBhZ2luYXRpb24vZW50aXRpZXMtcGFnaW5hdGlvbi5tb2RlbCc7XG5pbXBvcnQgeyBjcmVhdGVDcnVkVHJhaXRNdXRhdG9ycyB9IGZyb20gJy4vY3J1ZC1lbnRpdGllcy50cmFpdC5tdXRhdG9ycyc7XG5cbi8qKlxuICogR2VuZXJhdGVzIG5ncnggY29kZSB0byBhZGQsIHJlbW92ZSB1cGRhdGUsIHVwc2VydCBlbnRpdGllcyBvbiBhIGxpc3QsIGl0IGFsc29cbiAqIHRyYWNrcyB0aGUgY2hhbmdlcyBtYWRlLCBoZWxwZnVsIGZvciBpbXBsZW1lbnRpbmcgYmF0Y2ggdXBkYXRlcy4gVGhlIGBzdG9yZUNoYW5nZXNgIChmYWxzZSBieSBkZWZhdWx0KSxcbiAqIHdpbGwgc3RvcmUgZm9yIGFkZCBhbmQgdXBkYXRlIHRoZSBjaGFuZ2VkIGVudGl0eSBwcm9wcyBpbiB0aGUgcHJvcGVydHkgYGVudGl0eUNoYW5nZXNgIG9mIHRoZSBgQ2hhbmdlYCBvYmplY3QuXG4gKiBAcGFyYW0gY29uZmlnXG4gKiBAcGFyYW0gY29uZmlnLnN0b3JlQ2hhbmdlcyAtIFdpbGwgc3RvcmUgdGhlIGNoYW5nZXMgbWFkZSwgZGVmYXVsdCBmYWxzXG4gKlxuICogQGV4YW1wbGVcbiAqIC8vIFRoZSBmb2xsb3dpbmcgdHJhaXQgY29uZmlnXG4gKlxuICogZXhwb3J0IGludGVyZmFjZSBUZXN0U3RhdGVcbiAqIGV4dGVuZHMgRW50aXR5QW5kU3RhdHVzU3RhdGU8VG9kbz4sIENydWRTdGF0ZTxUb2RvPnt9XG4gKlxuICogICAgY29uc3QgdHJhaXRzID0gY3JlYXRlRW50aXR5RmVhdHVyZUZhY3RvcnkoXG4gKiAgICAgIGFkZExvYWRFbnRpdGllc1RyYWl0PFRvZG8+KCksXG4gKiAgICAgIGFkZENydWRFbnRpdGllc1RyYWl0PFRvZG8+KClcbiAqICAgICkoe1xuICogICAgICBhY3Rpb25zR3JvdXBLZXk6ICdbVG9kb3NdJyxcbiAqICAgICAgZmVhdHVyZVNlbGVjdG9yOiBjcmVhdGVGZWF0dXJlU2VsZWN0b3I8VGVzdFN0YXRlPj4oXG4gKiAgICAgICAgJ3RvZG9zJyxcbiAqICAgICAgKSxcbiAqICAgIH0pO1xuICpcbiAqIC8vICAgYWRkcyBmb2xsb3dpbmcgcHJvcHMgdG8gdGhlIHN0YXRlOlxuICogLy8gICAgY2hhbmdlczogQ2hhbmdlPFRvZG8+W107XG4gKlxuICogLy8gZ2VuZXJhdGVkIGFjdGlvbnNcbiAqIHRyYWl0cy5hY3Rpb25zLmFkZFRvZG9zKGVudGl0eTEsZW50aXR5Mi4uLilcbiAqIHRyYWl0cy5hY3Rpb25zLnVwZGF0ZVRvZG9zKHtpZDogaWQxLCBjaGFuZ2VzOntwcm9wMX19LHtpZDogaWQyLCBjaGFuZ2VzOntwcm9wMn19IC4uLilcbiAqIHRyYWl0cy5hY3Rpb25zLnVwc2VydFRvZG9zKGVudGl0eTEsZW50aXR5Mi4uLilcbiAqIHRyYWl0cy5hY3Rpb25zLnJlbW92ZUFsbFRvZG9zKClcbiAqIHRyYWl0cy5hY3Rpb25zLmNsZWFyVG9kb3NDaGFuZ2VzKClcbiAqIC8vIGdlbmVyYXRlZCBzZWxlY3RvcnNcbiAqIHRyYWl0cy5zZWxlY3RvcnMuc2VsZWN0VG9kb3NDaGFuZ2VzTGlzdCgpXG4gKiB0cmFpdHMuc2VsZWN0b3JzLnNlbGVjdEZpbHRlcmVkVG9kb3NDaGFuZ2VzTGlzdCgpXG4gKiB0cmFpdHMuc2VsZWN0b3JzLnNlbGVjdEFsbEZpbHRlcmVkQ2hhbmdlcygpXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhZGRDcnVkRW50aXRpZXNUcmFpdDxFbnRpdHk+KHtcbiAgc3RvcmVDaGFuZ2VzID0gZmFsc2UsXG59OiBDcnVkRW50aXRpZXNDb25maWcgPSB7fSkge1xuICByZXR1cm4gY3JlYXRlVHJhaXRGYWN0b3J5KHtcbiAgICBrZXk6IGNydWRFbnRpdGllc1RyYWl0S2V5LFxuICAgIGRlcGVuZHM6IFtsb2FkRW50aXRpZXNUcmFpdEtleV0sXG4gICAgY29uZmlnOiB7IHN0b3JlQ2hhbmdlcyB9IGFzIENydWRFbnRpdGllc0NvbmZpZyxcbiAgICBhY3Rpb25zOiAoeyBhY3Rpb25zR3JvdXBLZXksIGVudGl0aWVzTmFtZSB9OiBUcmFpdEFjdGlvbnNGYWN0b3J5Q29uZmlnKSA9PlxuICAgICAgY3JlYXRlQ3J1ZFRyYWl0QWN0aW9uczxFbnRpdHk+KGFjdGlvbnNHcm91cEtleSwgZW50aXRpZXNOYW1lKSxcbiAgICBzZWxlY3RvcnM6ICh7IHByZXZpb3VzU2VsZWN0b3JzIH06IFRyYWl0U2VsZWN0b3JzRmFjdG9yeUNvbmZpZykgPT5cbiAgICAgIGNyZWF0ZUNydWRUcmFpdFNlbGVjdG9yczxFbnRpdHk+KFxuICAgICAgICBwcmV2aW91c1NlbGVjdG9ycyBhcyBMb2FkRW50aXRpZXNTZWxlY3RvcnM8RW50aXR5PlxuICAgICAgKSxcbiAgICBtdXRhdG9yczogKHsgYWxsQ29uZmlncyB9OiBUcmFpdFN0YXRlTXV0YXRvcnNGYWN0b3J5Q29uZmlnKSA9PlxuICAgICAgY3JlYXRlQ3J1ZFRyYWl0TXV0YXRvcnM8RW50aXR5PihcbiAgICAgICAgYWxsQ29uZmlncyBhcyBDcnVkRW50aXRpZXNLZXllZENvbmZpZyAmIExvYWRFbnRpdGllc0tleWVkQ29uZmlnPEVudGl0eT5cbiAgICAgICksXG4gICAgaW5pdGlhbFN0YXRlOiAoeyBwcmV2aW91c0luaXRpYWxTdGF0ZSB9OiBUcmFpdEluaXRpYWxTdGF0ZUZhY3RvcnlDb25maWcpID0+XG4gICAgICBjcmVhdGVDcnVkSW5pdGlhbFN0YXRlPEVudGl0eT4ocHJldmlvdXNJbml0aWFsU3RhdGUpLFxuICAgIHJlZHVjZXI6ICh7IGluaXRpYWxTdGF0ZSwgYWxsQWN0aW9ucywgYWxsTXV0YXRvcnMsIGFsbENvbmZpZ3MgfSkgPT5cbiAgICAgIGNyZWF0ZUNydWRUcmFpdFJlZHVjZXIoXG4gICAgICAgIGluaXRpYWxTdGF0ZSxcbiAgICAgICAgYWxsQWN0aW9ucyBhcyBDcnVkRW50aXRpZXNBY3Rpb25zPEVudGl0eT4gJlxuICAgICAgICAgIExvYWRFbnRpdGllc0FjdGlvbnM8RW50aXR5PiAmXG4gICAgICAgICAgU29ydEVudGl0aWVzQWN0aW9uczxFbnRpdHk+ICZcbiAgICAgICAgICBGaWx0ZXJFbnRpdGllc0FjdGlvbnM8YW55PiAmXG4gICAgICAgICAgRW50aXRpZXNQYWdpbmF0aW9uQWN0aW9ucyxcbiAgICAgICAgYWxsTXV0YXRvcnMsXG4gICAgICAgIGFsbENvbmZpZ3MgYXMgQ3J1ZEVudGl0aWVzS2V5ZWRDb25maWcgJlxuICAgICAgICAgIEZpbHRlckVudGl0aWVzS2V5ZWRDb25maWc8RW50aXR5LCB1bmtub3duPiAmXG4gICAgICAgICAgTG9hZEVudGl0aWVzS2V5ZWRDb25maWc8RW50aXR5PiAmXG4gICAgICAgICAgU29ydEVudGl0aWVzS2V5ZWRDb25maWc8RW50aXR5PiAmXG4gICAgICAgICAgRW50aXRpZXNQYWdpbmF0aW9uS2V5ZWRDb25maWdcbiAgICAgICksXG4gIH0pO1xufVxuIl19

package/esm2020/crud-entities/crud-entities.trait.mutators.mjs

@@ -0,0 +1,121 @@
+import { ChangeType, } from './crud-entities.model';
+export function createCrudTraitMutators(allConfigs) {
+    const { storeChanges } = allConfigs.crud || {};
+    const adapter = allConfigs.loadEntities.adapter;
+    function generateChangeEntry(entity, changeType, customId) {
+        return {
+            id: customId ?? adapter.selectId(entity),
+            changeType,
+            entityChanges: (storeChanges && entity) || undefined,
+        };
+    }
+    function addEntities(entities, state, addFirst = false) {
+        const changes = [
+            ...state.changes,
+            ...entities.map((entity) => generateChangeEntry(entity, ChangeType.CREATED)),
+        ];
+        if (!addFirst)
+            return adapter.addMany(entities, {
+                ...state,
+                changes,
+            });
+        const newIds = entities.map((e) => adapter.selectId(e));
+        const newEntities = { ...state.entities };
+        entities.forEach((e) => {
+            const id = adapter.selectId(e);
+            newEntities[id] = e;
+        });
+        return {
+            ...state,
+            ids: [...newIds, ...state.ids],
+            entities: newEntities,
+            changes,
+        };
+    }
+    function upsertEntities(entities, state) {
+        const oldChanges = [...state.changes];
+        const existingIds = adapter.getSelectors().selectIds(state);
+        const [additions, updates] = entities.reduce(([a, u], entity) => existingIds.indexOf(adapter.selectId(entity)) !== -1
+            ? [a, [...u, entity]]
+            : [[...a, entity], u], [new Array(), new Array()]);
+        return adapter.upsertMany(entities, {
+            ...state,
+            changes: [
+                ...oldChanges,
+                ...additions.map((entity) => generateChangeEntry(entity, ChangeType.CREATED)),
+                ...updates.map((entity) => generateChangeEntry(entity, ChangeType.UPDATED)),
+            ],
+        });
+    }
+    function removeEntities(keysOrPredicate, state) {
+        if (typeof keysOrPredicate === 'function') {
+            return adapter.removeMany(keysOrPredicate, {
+                ...state,
+                changes: [
+                    ...state.changes,
+                    ...state.ids.map((id) => ({
+                        id,
+                        changeType: ChangeType.DELETED,
+                    })),
+                ],
+            });
+        }
+        return adapter.removeMany(keysOrPredicate, {
+            ...state,
+            changes: [
+                ...state.changes,
+                ...keysOrPredicate.map((key) => ({
+                    id: key,
+                    changeType: ChangeType.DELETED,
+                })),
+            ],
+        });
+    }
+    function removeAllEntities(state) {
+        return adapter.removeAll({
+            ...state,
+            changes: [
+                ...state.changes,
+                ...state.ids.map((id) => ({
+                    id,
+                    changeType: ChangeType.DELETED,
+                })),
+            ],
+        });
+    }
+    function clearEntitiesChanges(state) {
+        return { ...state, changes: [] };
+    }
+    function updateEntities(updates, state) {
+        const oldChanges = [...state.changes];
+        updates.forEach((updated) => {
+            const id = adapter.selectId(updated.changes);
+            if (id && id !== updated.id) {
+                // if the id changes update the id of pold changes
+                const index = oldChanges.findIndex((v) => v.id === updated.id);
+                const oldChange = oldChanges[index];
+                oldChanges[index] = { ...oldChange, id };
+            }
+        });
+        return adapter.updateMany(updates, {
+            ...state,
+            changes: [
+                ...oldChanges,
+                ...updates.map((updated) => ({
+                    id: adapter.selectId(updated.changes) ?? updated.id,
+                    changeType: ChangeType.UPDATED,
+                    entityChanges: (storeChanges && updated.changes) || undefined,
+                })),
+            ],
+        });
+    }
+    return {
+        addEntities,
+        removeEntities,
+        updateEntities,
+        removeAllEntities,
+        clearEntitiesChanges,
+        upsertEntities,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crud-entities.trait.mutators.js","sourceRoot":"","sources":["../../../../../../libs/ngrx-traits/common/src/lib/crud-entities/crud-entities.trait.mutators.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Change,\n  ChangeType,\n  CrudEntitiesKeyedConfig,\n  CrudEntitiesMutators,\n  CrudEntitiesState,\n} from './crud-entities.model';\nimport { Predicate, Update } from '@ngrx/entity';\nimport {\n  LoadEntitiesKeyedConfig,\n  LoadEntitiesState,\n} from '../load-entities/load-entities.model';\n\nexport function createCrudTraitMutators<Entity>(\n  allConfigs: CrudEntitiesKeyedConfig & LoadEntitiesKeyedConfig<Entity>\n): CrudEntitiesMutators<Entity> {\n  const { storeChanges } = allConfigs.crud || {};\n  const adapter = allConfigs!.loadEntities!.adapter;\n\n  function generateChangeEntry(\n    entity: Entity,\n    changeType: ChangeType,\n    customId?: string | number\n  ) {\n    return {\n      id: customId ?? adapter.selectId(entity),\n      changeType,\n      entityChanges: (storeChanges && entity) || undefined,\n    };\n  }\n\n  function addEntities<\n    S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>\n  >(entities: Entity[], state: S, addFirst = false) {\n    const changes = [\n      ...state.changes,\n      ...entities.map((entity) =>\n        generateChangeEntry(entity, ChangeType.CREATED)\n      ),\n    ];\n    if (!addFirst)\n      return adapter.addMany(entities, {\n        ...state,\n        changes,\n      });\n\n    const newIds = entities.map((e) => adapter.selectId(e));\n    const newEntities = { ...state.entities };\n    entities.forEach((e) => {\n      const id = adapter.selectId(e);\n      newEntities[id] = e;\n    });\n    return {\n      ...state,\n      ids: [...newIds, ...state.ids],\n      entities: newEntities,\n      changes,\n    };\n  }\n\n  function upsertEntities<\n    S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>\n  >(entities: Entity[], state: S) {\n    const oldChanges = [...state.changes];\n    const existingIds = adapter.getSelectors().selectIds(state) as string[];\n\n    const [additions, updates] = entities.reduce(\n      ([a, u], entity) =>\n        existingIds.indexOf(adapter.selectId(entity as Entity) as string) !== -1\n          ? [a, [...u, entity]]\n          : [[...a, entity], u],\n      [new Array<Entity>(), new Array<Entity>()]\n    );\n\n    return adapter.upsertMany(entities, {\n      ...state,\n      changes: [\n        ...oldChanges,\n\n        ...additions.map((entity) =>\n          generateChangeEntry(entity, ChangeType.CREATED)\n        ),\n        ...updates.map((entity) =>\n          generateChangeEntry(entity, ChangeType.UPDATED)\n        ),\n      ],\n    });\n  }\n\n  function removeEntities<\n    S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>\n  >(keys: number[], state: S): S;\n  function removeEntities<\n    S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>\n  >(keys: string[], state: S): S;\n  function removeEntities<\n    S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>\n  >(predicate: Predicate<Entity>, state: S): S;\n  function removeEntities<\n    S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>\n  >(keysOrPredicate: Predicate<Entity> | string[] | number[], state: S): S {\n    if (typeof keysOrPredicate === 'function') {\n      return adapter.removeMany(keysOrPredicate, {\n        ...state,\n        changes: [\n          ...state.changes,\n          ...(state.ids as any[]).map((id) => ({\n            id,\n            changeType: ChangeType.DELETED,\n          })),\n        ],\n      });\n    }\n\n    return adapter.removeMany(keysOrPredicate as string[], {\n      ...state,\n      changes: [\n        ...state.changes,\n        ...(keysOrPredicate as string[]).map((key: string) => ({\n          id: key,\n          changeType: ChangeType.DELETED,\n        })),\n      ],\n    });\n  }\n  function removeAllEntities<\n    S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>\n  >(state: S): S {\n    return adapter.removeAll({\n      ...state,\n      changes: [\n        ...state.changes,\n        ...(state.ids as any[]).map((id) => ({\n          id,\n          changeType: ChangeType.DELETED,\n        })),\n      ],\n    });\n  }\n  function clearEntitiesChanges<\n    S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>\n  >(state: S) {\n    return { ...state, changes: [] };\n  }\n\n  function updateEntities<\n    S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>\n  >(updates: Update<Entity>[], state: S) {\n    const oldChanges = [...state.changes];\n    updates.forEach((updated) => {\n      const id = adapter.selectId(updated.changes as Entity);\n      if (id && id !== updated.id) {\n        // if the id changes update the id of pold changes\n        const index = oldChanges.findIndex((v) => v.id === updated.id);\n        const oldChange = oldChanges[index];\n        oldChanges[index] = { ...oldChange, id };\n      }\n    });\n    return adapter.updateMany(updates, {\n      ...state,\n      changes: [\n        ...oldChanges,\n        ...updates.map(\n          (updated) =>\n            ({\n              id: adapter.selectId(updated.changes as Entity) ?? updated.id,\n              changeType: ChangeType.UPDATED,\n              entityChanges: (storeChanges && updated.changes) || undefined,\n            } as Change<Entity>)\n        ),\n      ],\n    });\n  }\n\n  return {\n    addEntities,\n    removeEntities,\n    updateEntities,\n    removeAllEntities,\n    clearEntitiesChanges,\n    upsertEntities,\n  };\n}\n"]}

package/esm2020/crud-entities/crud-entities.trait.reducer.mjs

@@ -0,0 +1,17 @@
+import { createReducer, on } from '@ngrx/store';
+import { insertIf } from '@ngrx-traits/core';
+export function createCrudInitialState(previousInitialState) {
+    return {
+        ...previousInitialState,
+        changes: [],
+    };
+}
+export function createCrudTraitReducer(initialState, allActions, allMutators, allConfigs) {
+    const sortRemote = allConfigs.sort?.remote;
+    const filterRemote = allConfigs.filter && !allConfigs.filter?.filterFn;
+    const paginationCacheType = allConfigs.pagination?.cacheType;
+    return createReducer(initialState, on(allActions.addEntities, (state, { entities }) => allMutators.addEntities(entities, state)), on(allActions.updateEntities, (state, { updates }) => allMutators.updateEntities(updates, state)), on(allActions.upsertEntities, (state, { entities }) => allMutators.upsertEntities(entities, state)), on(allActions.removeEntities, (state, { keys }) => allMutators.removeEntities(keys, state)), on(allActions.removeAllEntities, (state, { predicate }) => predicate
+        ? allMutators.removeEntities(predicate, state)
+        : allMutators.removeAllEntities(state)), on(allActions.clearEntitiesChanges, (state) => allMutators.clearEntitiesChanges(state)), ...insertIf(sortRemote, () => on(allActions.sortEntities, (state) => allMutators.clearEntitiesChanges(state))), ...insertIf(filterRemote, () => on(allActions.filterEntities, (state) => allMutators.clearEntitiesChanges(state))), ...insertIf(!allActions.loadEntitiesPageSuccess, () => on(allActions.loadEntitiesSuccess, (state) => allMutators.clearEntitiesChanges(state))), ...insertIf(!!allActions.loadEntitiesPageSuccess && paginationCacheType === 'partial', () => on(allActions.loadEntitiesPageSuccess, (state) => allMutators.clearEntitiesChanges(state))));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/crud-entities/crud-entities.trait.selectors.mjs

@@ -0,0 +1,54 @@
+import { createSelector } from '@ngrx/store';
+import { ChangeType, } from './crud-entities.model';
+export function createCrudTraitSelectors(previousSelectors) {
+    function selectChanges(state) {
+        return state.changes;
+    }
+    function selectFilteredChanges(state) {
+        const cache = {};
+        return state.changes.reduce((acc, value) => {
+            const changes = cache[value.id];
+            if (!changes) {
+                cache[value.id] = [value.changeType];
+                acc.push(value);
+                return acc;
+            }
+            if (value.changeType === ChangeType.UPDATED) {
+                return acc;
+            }
+            if (value.changeType === ChangeType.DELETED &&
+                changes.includes(ChangeType.CREATED)) {
+                delete cache[value.id];
+                return acc.filter((v) => v.id !== value.id);
+            }
+            if (value.changeType === ChangeType.DELETED) {
+                delete cache[value.id];
+                const newAcc = acc.filter((v) => v.id !== value.id);
+                newAcc.push(value);
+                return newAcc;
+            }
+            return acc;
+        }, []);
+    }
+    const { selectEntitiesMap } = previousSelectors;
+    const selectEntitiesChangesList = createSelector((state) => selectEntitiesMap(state), selectChanges, (entities, changed) => {
+        const map = changed.map((change) => ({
+            changeType: change.changeType,
+            entity: entities[change.id] ?? {
+                id: change.id,
+            },
+        }));
+        return map;
+    });
+    const selectFilteredEntitiesChangesList = createSelector(selectFilteredChanges, (state) => selectEntitiesMap(state), (changes, entities) => changes.map((c) => {
+        return {
+            entity: entities[c.id] ?? { id: c.id },
+            changeType: c.changeType,
+        };
+    }));
+    return {
+        selectEntitiesChangesList,
+        selectFilteredEntitiesChangesList,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/crud-entities/index.mjs

@@ -0,0 +1,3 @@
+export * from './crud-entities.model';
+export * from './crud-entities.trait';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25ncngtdHJhaXRzL2NvbW1vbi9zcmMvbGliL2NydWQtZW50aXRpZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jcnVkLWVudGl0aWVzLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vY3J1ZC1lbnRpdGllcy50cmFpdCc7XG4iXX0=

package/esm2020/entities-pagination/entities-pagination.model.internal.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXRpZXMtcGFnaW5hdGlvbi5tb2RlbC5pbnRlcm5hbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmdyeC10cmFpdHMvY29tbW9uL3NyYy9saWIvZW50aXRpZXMtcGFnaW5hdGlvbi9lbnRpdGllcy1wYWdpbmF0aW9uLm1vZGVsLmludGVybmFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBY3Rpb25DcmVhdG9yLCBUeXBlZEFjdGlvbiB9IGZyb20gJ0BuZ3J4L3N0b3JlL3NyYy9tb2RlbHMnO1xuaW1wb3J0IHtcbiAgRW50aXRpZXNQYWdpbmF0aW9uQWN0aW9ucyxcbiAgRW50aXRpZXNQYWdpbmF0aW9uU2VsZWN0b3JzLFxuICBFbnRpdGllc1BhZ2luYXRpb25TdGF0ZSxcbn0gZnJvbSAnLi9lbnRpdGllcy1wYWdpbmF0aW9uLm1vZGVsJztcbmltcG9ydCB7IExvYWRFbnRpdGllc1N0YXRlIH0gZnJvbSAnLi4vbG9hZC1lbnRpdGllcy9sb2FkLWVudGl0aWVzLm1vZGVsJztcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IHR5cGUgxp9QYWdpbmF0aW9uQWN0aW9ucyA9IEVudGl0aWVzUGFnaW5hdGlvbkFjdGlvbnMgJiB7XG4gIHNldEVudGl0aWVzUmVxdWVzdFBhZ2U6IEFjdGlvbkNyZWF0b3I8XG4gICAgc3RyaW5nLFxuICAgIChwcm9wczogeyBpbmRleDogbnVtYmVyIH0pID0+IHsgaW5kZXg6IG51bWJlciB9ICYgVHlwZWRBY3Rpb248c3RyaW5nPlxuICA+O1xufTtcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IHR5cGUgxp9FbnRpdGllc1BhZ2luYXRpb25TZWxlY3RvcnM8RW50aXR5PiA9XG4gIEVudGl0aWVzUGFnaW5hdGlvblNlbGVjdG9yczxFbnRpdHk+ICYge1xuICAgIGlzRW50aXRpZXNDdXJyZW50UGFnZUluQ2FjaGU6IChcbiAgICAgIHN0YXRlOiBMb2FkRW50aXRpZXNTdGF0ZTxFbnRpdHk+ICYgRW50aXRpZXNQYWdpbmF0aW9uU3RhdGVcbiAgICApID0+IGJvb2xlYW47XG4gICAgaXNFbnRpdGllc05leHRQYWdlSW5DYWNoZTogKFxuICAgICAgc3RhdGU6IExvYWRFbnRpdGllc1N0YXRlPEVudGl0eT4gJiBFbnRpdGllc1BhZ2luYXRpb25TdGF0ZVxuICAgICkgPT4gYm9vbGVhbjtcbiAgfTtcbiJdfQ==

package/esm2020/entities-pagination/entities-pagination.model.mjs

@@ -0,0 +1,2 @@
+export const entitiesPaginationTraitKey = 'pagination';
+//# sourceMappingURL=data:application/json;base64,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