@ngrx-traits/common 0.0.1

package/index.d.ts

@@ -0,0 +1,11 @@
+export * from './load-entities';
+export * from './filter-entities';
+export * from './entities-pagination';
+export * from './select-entities';
+export * from './select-entity';
+export * from './crud-entities';
+export * from './sort-entities';
+export * from './reset';
+export * from './load-entity';
+export * from './async-action';
+export * from './set-entity';

package/load-entities/index.d.ts

@@ -0,0 +1,2 @@
+export * from './load-entities.model';
+export * from './load-entities.trait';

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

@@ -0,0 +1,97 @@
+import { Comparer, EntityAdapter, EntityState, IdSelector } from '@ngrx/entity';
+import { ActionCreator, TypedAction } from '@ngrx/store/src/models';
+import { Dictionary } from '@ngrx/entity/src/models';
+import { KeyedConfig } from '@ngrx-traits/core';
+export declare type Status = 'loading' | 'success' | 'fail';
+export interface StatusState {
+    status?: Status;
+}
+export interface LoadEntitiesState<T> extends EntityState<T>, StatusState {
+}
+export declare type LoadEntitiesActions<T> = {
+    /**
+     * load entities from backend
+     */
+    loadEntities: ActionCreator<string, () => TypedAction<string>>;
+    /**
+     * entities where loaded successfully
+     */
+    loadEntitiesSuccess: ActionCreator<string, (props: {
+        entities: T[];
+        total?: number;
+    }) => {
+        entities: T[];
+        total?: number;
+    } & TypedAction<string>>;
+    /**
+     * entities failed loading
+     */
+    loadEntitiesFail: ActionCreator<string, (props?: {
+        error?: string;
+    }) => {
+        error?: string;
+    } & TypedAction<string>>;
+};
+export declare type LoadEntitiesSelectors<T> = {
+    /**
+     * returns all ids of the entities in an array
+     * @param state
+     */
+    selectEntitiesIdsList: (state: LoadEntitiesState<T>) => string[] | number[];
+    /**
+     * returns all entities in a map with the id as key of the map
+     * @param state
+     */
+    selectEntitiesMap: (state: LoadEntitiesState<T>) => Dictionary<T>;
+    /**
+     * returns all entities in an array
+     * @param state
+     */
+    selectEntitiesList: (state: LoadEntitiesState<T>) => T[];
+    /**
+     * returns the total number of entities
+     * @param state
+     */
+    selectEntitiesTotal: (state: LoadEntitiesState<T>) => number;
+    /**
+     * is currently loading entities
+     * @param state
+     */
+    isEntitiesLoading: (state: LoadEntitiesState<T>) => boolean;
+    /**
+     * were the entities loaded successfully
+     * @param state
+     */
+    isEntitiesLoadingSuccess: (state: LoadEntitiesState<T>) => boolean;
+    /**
+     * did the entities fail loading
+     * @param state
+     */
+    isEntitiesLoadingFail: (state: LoadEntitiesState<T>) => boolean;
+};
+export declare type LoadEntitiesMutators<T> = {
+    /**
+     * set or replace all entities currently in store
+     * @param entities
+     * @param state
+     */
+    setEntitiesList<S extends LoadEntitiesState<T>>(entities: T[], state: S): S;
+};
+export declare type GenericActionCreator = ActionCreator<string, (...args: unknown[]) => TypedAction<string>>;
+export declare const loadEntitiesTraitKey = "loadEntities";
+export declare type LoadEntitiesConfig<T = unknown> = {
+    /**
+     * Function that returns the id of an entity if not set it attempts to return the values
+     * of a property call id, this is pass to @ngrx/entity EntityAdapter
+     */
+    selectId?: IdSelector<T>;
+    /**
+     *  Default sort function for to @ngrx/entity EntityAdapter
+     */
+    sortComparer?: false | Comparer<T>;
+    /**
+     *  @ngrx/entity EntityAdapter
+     */
+    adapter: EntityAdapter<T>;
+};
+export declare type LoadEntitiesKeyedConfig<T> = KeyedConfig<typeof loadEntitiesTraitKey, LoadEntitiesConfig<T>>;

package/load-entities/load-entities.mutators.d.ts

@@ -0,0 +1,3 @@
+import { LoadEntitiesKeyedConfig, LoadEntitiesMutators } from './load-entities.model';
+import { EntitiesPaginationKeyedConfig } from '../entities-pagination';
+export declare function createLoadEntitiesTraitMutators<Entity>(allConfigs: LoadEntitiesKeyedConfig<Entity> & EntitiesPaginationKeyedConfig): LoadEntitiesMutators<Entity>;

package/load-entities/load-entities.trait.actions.d.ts

@@ -0,0 +1,2 @@
+import { LoadEntitiesActions } from './load-entities.model';
+export declare function createLoadEntitiesTraitActions<Entity>(actionsGroupKey: string, entitiesName: string): LoadEntitiesActions<Entity>;

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

@@ -0,0 +1,39 @@
+import { LoadEntitiesState, LoadEntitiesConfig } from './load-entities.model';
+/**
+ * Generates the ngrx code needed to load a list of entities from the backend
+ * with a load[EntitiesName], load[EntitiesName]Success, load[EntitiesName]Fail actions, and selectors to query the
+ * entities like selectEntity[EntitiesName]List, selectEntity[EntitiesName]Ids, selectEntity[EntitiesName]Map, and its progress loading
+ * with isLoading[EntitiesName],isLoading[EntitiesName]Success, isLoading[EntitiesName]Fail. This trait is the base for all other traits related
+ * to a list of entities, the other will call loadEntities when needing data.
+ * @param traitConfig - Config object fot the trait factory
+ * @param traitConfig.selectId - Function that returns the id of an entity
+ * @param traitConfig.sortComparer - Default sort function for to @ngrx/entity EntityAdapter
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends LoadEntitiesState<Todo>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      {entityName: 'Todo'},
+ *      addLoadEntitiesTrait<Todo>(),
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate the actions and selectors
+ * traits.actions.loadTodos()
+ * traits.actions.loadTodosSuccess({entities: todos})
+ * traits.actions.loadTodosFail();
+ * traits.selectors.selectTodosList
+ * traits.selectors.selectTodosMap
+ * traits.selectors.selectTodosIds
+ * traits.selectors.selectTodosTotal
+ * traits.selectors.isLoadingTodos
+ * traits.selectors.isSuccessTodosSuccess
+ * traits.selectors.isFailTodosFail
+ */
+export declare function addLoadEntitiesTrait<Entity>(traitConfig?: Omit<LoadEntitiesConfig<Entity>, 'adapter'>): import("@ngrx-traits/core").TraitFactory<LoadEntitiesState<Entity>, import("./load-entities.model").LoadEntitiesActions<Entity>, import("./load-entities.model").LoadEntitiesSelectors<Entity>, import("./load-entities.model").LoadEntitiesMutators<Entity>, "loadEntities", LoadEntitiesConfig<Entity>, import("@ngrx-traits/core").AllTraitConfigs>;

package/load-entities/load-entities.trait.reducer.d.ts

@@ -0,0 +1,4 @@
+import { LoadEntitiesState, LoadEntitiesActions, LoadEntitiesKeyedConfig, LoadEntitiesMutators } from './load-entities.model';
+import { EntitiesPaginationKeyedConfig } from '../entities-pagination';
+export declare function createLoadEntitiesInitialState<Entity>(previousInitialState: {} | undefined, allConfigs: LoadEntitiesKeyedConfig<Entity>): LoadEntitiesState<Entity>;
+export declare function createLoadEntitiesTraitReducer<T, S extends LoadEntitiesState<T>>(initialState: S, actions: LoadEntitiesActions<T>, allMutators: LoadEntitiesMutators<T>, allConfigs: LoadEntitiesKeyedConfig<T> & EntitiesPaginationKeyedConfig): import("@ngrx/store").ActionReducer<S, import("@ngrx/store").Action>;

package/load-entities/load-entities.trait.selectors.d.ts

@@ -0,0 +1,3 @@
+import { LoadEntitiesKeyedConfig, LoadEntitiesSelectors } from './load-entities.model';
+import { FilterEntitiesKeyedConfig } from '../filter-entities';
+export declare function createLoadEntitiesTraitSelectors<Entity>(allConfigs?: LoadEntitiesKeyedConfig<Entity> & FilterEntitiesKeyedConfig<Entity, unknown>): LoadEntitiesSelectors<Entity>;

package/load-entities/load-entities.utils.d.ts

@@ -0,0 +1,4 @@
+import { StatusState } from './load-entities.model';
+export declare function isLoading<S extends StatusState>(state: S): boolean;
+export declare function isSuccess<S extends StatusState>(state: S): boolean;
+export declare function isFail<S extends StatusState>(state: S): boolean;

package/load-entity/index.d.ts

@@ -0,0 +1,2 @@
+export * from './load-entity.traits';
+export * from './load-entity.model';

package/load-entity/load-entity.model.d.ts

@@ -0,0 +1,9 @@
+import { PostfixProps, PrefixProps, TraitActions } from '@ngrx-traits/core';
+import { AsyncActionActions, AsyncActionState } from '../async-action/async-action.model';
+export declare type LoadEntityActions<J extends string, Request extends object, Response extends object, Failure extends object> = PrefixProps<AsyncActionActions<Request, Response, Failure, J>, 'load'> & TraitActions;
+export declare type LoadEntityState<T, J extends string> = AsyncActionState<`load${Capitalize<J & string>}`> & PrefixProps<{
+    ''?: T;
+}, J>;
+export declare type LoadEntitySelectors<T, J extends string> = PostfixProps<{
+    select: (state: LoadEntityState<T, J>) => T;
+}, J>;

package/load-entity/load-entity.traits.d.ts

@@ -0,0 +1,64 @@
+import { ActionCreatorProps } from '@ngrx/store/src/models';
+import { LoadEntityState } from './load-entity.model';
+declare type RecordEntity<T> = T extends Record<string, infer J> ? J : never;
+/**
+ * Generates ngrx code needed to load and entity and store it in a state
+ * @param entityName - Entity name, should be in camel case
+ * @param options.actionProps - Optional param for the main request action,
+ * use the props() function for its value, if not present action will have no params,
+ * @param options.actionSuccessProps - Optional param for the request success
+ * action, use the props() function for its value, if not present action success will have no params
+ * @param options.actionFailProps - Optional param for the request fail action,
+ * use the props() function for its value, if not present action fail will have no params
+ * @returns the trait factory
+ *
+ * @example
+ * const traits = createEntityFeatureFactory(
+ * ...addLoadEntityTraits({
+ *        entityName: 'client',
+ *        requestProps: props<{ id: string }>(),
+ *        responseProps: props<{ client: Client }>(),
+ *      }),
+ * )({
+ *      actionsGroupKey: 'Client',
+ *      featureSelector: createFeatureSelector<
+ *        LoadEntityState<Client, 'client'>
+ *        >('client'),
+ *    });
+ *
+ * // will generate
+ * traits.actions.loadClient({id:123});
+ * traits.actions.loadClientSuccess({client: {id: '123', name: 'gabs'}});
+ * traits.actions.loadClientFail();
+ * traits.selectors.selectClient
+ * traits.selectors.isLoadingLoadClient
+ * traits.selectors.isSuccessLoadClient
+ * traits.selectors.isFailLoadClient
+ */
+export declare function addLoadEntityTraits<J extends string, Request extends object | undefined = undefined, Response extends Record<J, any> | undefined = undefined, Failure extends object | undefined = undefined, Entity = RecordEntity<Response>, State = LoadEntityState<Entity, J>>({ entityName, actionProps, actionSuccessProps, actionFailProps, }: {
+    entityName: J;
+    actionProps?: ActionCreatorProps<Request>;
+    actionSuccessProps?: ActionCreatorProps<Response>;
+    actionFailProps?: ActionCreatorProps<Failure>;
+}): readonly [import("@ngrx-traits/core").TraitFactory<import("@ngrx-traits/core").PrefixProps<import("@ngrx-traits/common").StatusState, `load${Capitalize<J & string>}`>, import("@ngrx-traits/core").PrefixProps<{
+    '': import("@ngrx-traits/common").ActionCreatorWithOptionalProps<Request>;
+    Success: import("@ngrx-traits/common").ActionCreatorWithOptionalProps<Response>;
+    Fail: import("@ngrx-traits/common").ActionCreatorWithOptionalProps<Failure>;
+}, `load${Capitalize<J & string>}`>, import("@ngrx-traits/core").PostfixProps<{
+    isLoading: (state: import("@ngrx-traits/core").PrefixProps<import("@ngrx-traits/common").StatusState, `load${Capitalize<J & string>}`>) => boolean;
+    isSuccess: (state: import("@ngrx-traits/core").PrefixProps<import("@ngrx-traits/common").StatusState, `load${Capitalize<J & string>}`>) => boolean;
+    isFail: (state: import("@ngrx-traits/core").PrefixProps<import("@ngrx-traits/common").StatusState, `load${Capitalize<J & string>}`>) => boolean;
+}, `load${Capitalize<J & string>}`>, {}, string, {
+    name: `load${Capitalize<J & string>}`;
+    actionProps: ActionCreatorProps<Request> | undefined;
+    actionSuccessProps: ActionCreatorProps<Response> | undefined;
+    actionFailProps: ActionCreatorProps<Failure> | undefined;
+}, import("@ngrx-traits/core").AllTraitConfigs>, import("@ngrx-traits/core").TraitFactory<State, {}, import("@ngrx-traits/core").PostfixProps<{
+    select: (state: LoadEntityState<Entity, J>) => Entity;
+}, J>, {}, string, {
+    entityName: J;
+    actionProps: ActionCreatorProps<Request> | undefined;
+    actionSuccessProps: ActionCreatorProps<Response> | undefined;
+    actionFailProps: ActionCreatorProps<Failure> | undefined;
+}, import("@ngrx-traits/core").AllTraitConfigs>];
+export {};

package/ngrx-traits-common.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@ngrx-traits/common" />
+export * from './public_api';

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@ngrx-traits/common",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^12.0.0",
+    "@angular/compiler": "^12.0.0",
+    "@angular/core": "^12.0.0",
+    "@ngrx/effects": "^12.2.0",
+    "@ngrx/entity": "^12.2.0",
+    "@ngrx/store": "^12.2.0",
+    "@ngrx-traits/core": "0.0.1",
+    "rxjs": "~6.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gabrielguerrero/ngrx-traits.git"
+  },
+  "main": "bundles/ngrx-traits-common.umd.js",
+  "module": "fesm2015/ngrx-traits-common.js",
+  "es2015": "fesm2015/ngrx-traits-common.js",
+  "esm2015": "esm2015/ngrx-traits-common.js",
+  "fesm2015": "fesm2015/ngrx-traits-common.js",
+  "typings": "ngrx-traits-common.d.ts",
+  "sideEffects": false,
+  "dependencies": {
+    "tslib": "^2.2.0"
+  }
+}

package/public_api.d.ts

@@ -0,0 +1 @@
+export * from './index';

package/reset/index.d.ts

@@ -0,0 +1 @@
+export * from './reset.trait';

package/reset/reset.trait.d.ts

@@ -0,0 +1,32 @@
+import { GenericActionCreator } from '../load-entities';
+/**
+ * Generates the ngrx code needed to reset the current state to the initial state.
+ * @param traitConfig - Config object fot the trait factory
+ * @param traitConfig.resetOn - set an extra action which will also trigger a reset state,
+ * useful if you want to create an action that reset several features states
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,FilterState<TodoFilter>{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addResetEntitiesStateTrait()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions, plus the ones generated by other traits
+ * traits.actions.resetTodosState()
+ */
+export declare function addResetEntitiesStateTrait(traitConfig?: {
+    resetOn?: GenericActionCreator[];
+}): import("@ngrx-traits/core").TraitFactory<{}, {
+    resetEntitiesState: import("@ngrx/store").ActionCreator<string, () => import("@ngrx/store/src/models").TypedAction<string>>;
+}, {}, {}, "reset", {
+    resetOn?: GenericActionCreator[] | undefined;
+}, import("@ngrx-traits/core").AllTraitConfigs>;

package/select-entities/index.d.ts

@@ -0,0 +1,3 @@
+export * from './select-entities.model';
+export * from './select-entities.trait';
+export * from './select-entities.utils';

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

@@ -0,0 +1,41 @@
+import { Dictionary } from '@ngrx/entity';
+import { LoadEntitiesState } from '../load-entities/load-entities.model';
+import { ActionCreator, TypedAction } from '@ngrx/store/src/models';
+export interface SelectEntitiesState {
+    selectedIds: Dictionary<boolean>;
+}
+export declare type SelectEntitiesActions = {
+    selectEntities: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & TypedAction<string>>;
+    deselectEntities: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & TypedAction<string>>;
+    toggleSelectEntities: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & TypedAction<string>>;
+    toggleSelectAllEntities: ActionCreator<string, () => TypedAction<string>>;
+    clearEntitiesSelection: ActionCreator<string, () => TypedAction<string>>;
+};
+export declare type SelectEntitiesSelectors<Entity> = {
+    isAllEntitiesSelected: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => Selected;
+    selectEntitiesIdsSelectedMap: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => Dictionary<boolean>;
+    selectEntitiesIdsSelectedList: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => number[] | string[];
+    selectEntitiesSelectedMap: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => Dictionary<Entity>;
+    selectEntitiesSelectedList: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => Entity[];
+    selectTotalSelectedEntities: (state: LoadEntitiesState<Entity> & SelectEntitiesState) => number;
+};
+export declare type SelectEntitiesMutators<Entity> = {
+    selectEntities: <S extends LoadEntitiesState<Entity> & SelectEntitiesState>(id: number | string, state: S) => S;
+    deselectEntities<S extends LoadEntitiesState<Entity> & SelectEntitiesState>(id: number | string, state: S): S;
+    toggleSelectEntities<S extends LoadEntitiesState<Entity> & SelectEntitiesState>(id: number | string, state: S): S;
+    toggleSelectAllEntities<S extends LoadEntitiesState<Entity> & SelectEntitiesState>(state: S): S;
+    clearEntitiesSelection<S extends LoadEntitiesState<Entity> & SelectEntitiesState>(state: S): S;
+};
+export declare type Selected = 'all' | 'some' | 'none';

package/select-entities/select-entities.trait.actions.d.ts

@@ -0,0 +1,2 @@
+import { SelectEntitiesActions } from './select-entities.model';
+export declare function createSelectEntitiesTraitActions(actionsGroupKey: string, entitiesName: string): SelectEntitiesActions;

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

@@ -0,0 +1,34 @@
+import { SelectEntitiesSelectors, SelectEntitiesActions } from './select-entities.model';
+/**
+ * Generates ngrx code to add multi selection to a list
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,MultipleSelectionState{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addSelectEntitiesTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions and selectors, plus the ones generated by other traits
+ * traits.actions.selectTodos({id})
+ * traits.actions.deselectTodos({id})
+ * traits.actions.toggleSectTodos({id})
+ * traits.actions.toggleSelectAllTodos()
+ * traits.actions.clearTodosSelection()
+ *
+ * traits.selectors.isAllTodosSelected()
+ * traits.selectors.selectTodosIdsSelectedMap()
+ * traits.selectors.selectTodosIdsSelectedList()
+ * traits.selectors.selectTodosSelectedMap()
+ * traits.selectors.selectTodosSelectedList()
+ * traits.selectors.selectTotalSelectedTodos()
+ */
+export declare function addSelectEntitiesTrait<Entity>(): import("@ngrx-traits/core").TraitFactory<import("../load-entities/load-entities.model").LoadEntitiesState<Entity> & import("./select-entities.model").SelectEntitiesState, SelectEntitiesActions, SelectEntitiesSelectors<Entity>, import("./select-entities.model").SelectEntitiesMutators<Entity>, "SelectEntities", unknown, import("@ngrx-traits/core").AllTraitConfigs>;

package/select-entities/select-entities.trait.mutators.d.ts

@@ -0,0 +1,2 @@
+import { SelectEntitiesMutators, SelectEntitiesSelectors } from './select-entities.model';
+export declare function createSelectEntitiesTraitMutators<Entity>({ isAllEntitiesSelected, }: SelectEntitiesSelectors<Entity>): SelectEntitiesMutators<Entity>;

package/select-entities/select-entities.trait.reducer.d.ts

@@ -0,0 +1,8 @@
+import { LoadEntitiesActions, LoadEntitiesKeyedConfig, LoadEntitiesState } from '../load-entities/load-entities.model';
+import { SortEntitiesActions, SortEntitiesKeyedConfig } from '../sort-entities/sort-entities.model';
+import { SelectEntitiesMutators, SelectEntitiesActions, SelectEntitiesState } from './select-entities.model';
+import { CrudEntitiesActions } from '../crud-entities/crud-entities.model';
+import { EntitiesPaginationActions, EntitiesPaginationKeyedConfig } from '../entities-pagination/entities-pagination.model';
+import { FilterEntitiesActions } from '../filter-entities';
+export declare function createSelectEntitiesInitialState<Entity>(previousInitialState: any): LoadEntitiesState<Entity> & SelectEntitiesState;
+export declare function createSelectEntitiesTraitReducer<Entity, S extends LoadEntitiesState<Entity> & SelectEntitiesState>(initialState: S, allActions: SelectEntitiesActions & CrudEntitiesActions<Entity> & SortEntitiesActions<Entity> & LoadEntitiesActions<Entity> & FilterEntitiesActions<any> & EntitiesPaginationActions, allMutators: SelectEntitiesMutators<Entity>, allConfigs: LoadEntitiesKeyedConfig<Entity> & EntitiesPaginationKeyedConfig & SortEntitiesKeyedConfig<Entity>): import("@ngrx/store").ActionReducer<S, import("@ngrx/store").Action>;

package/select-entities/select-entities.trait.selectors.d.ts

@@ -0,0 +1,3 @@
+import { SelectEntitiesSelectors } from './select-entities.model';
+import { LoadEntitiesSelectors } from '../load-entities';
+export declare function createSelectEntitiesTraitSelectors<Entity>(previousSelectors: LoadEntitiesSelectors<Entity>): SelectEntitiesSelectors<Entity>;

package/select-entities/select-entities.utils.d.ts

@@ -0,0 +1,7 @@
+import { SelectEntitiesState } from './select-entities.model';
+import { LoadEntitiesState } from '../load-entities';
+export declare function deselectEntities<S extends SelectEntitiesState>(id: number | string, state: S): S;
+export declare function selectEntities<S extends SelectEntitiesState>(id: number | string, state: S): S;
+export declare function toggleSelectEntities<S extends SelectEntitiesState>(id: number | string, state: S): S;
+export declare function clearEntitiesSelection<S extends SelectEntitiesState>(state: S): S;
+export declare function selectTotalSelectedEntities<Entity, S extends LoadEntitiesState<Entity> & SelectEntitiesState>(state: S): number;

package/select-entity/index.d.ts

@@ -0,0 +1,2 @@
+export * from './select-entity.trait';
+export * from './select-entity.model';

package/select-entity/select-entity.model.d.ts

@@ -0,0 +1,33 @@
+import { ActionCreator, TypedAction } from '@ngrx/store/src/models';
+import { KeyedConfig } from '@ngrx-traits/core';
+import { LoadEntitiesState } from '../load-entities/load-entities.model';
+export interface SelectEntityState {
+    selectedId?: number | string;
+}
+export declare type SelectEntityActions = {
+    selectEntity: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & TypedAction<string>>;
+    deselectEntity: ActionCreator<string, () => TypedAction<string>>;
+    toggleSelectEntity: ActionCreator<string, (props: {
+        id: number | string;
+    }) => {
+        id: number | string;
+    } & TypedAction<string>>;
+};
+export declare type SelectEntitySelectors<T> = {
+    selectEntityIdSelected: (state: LoadEntitiesState<T> & SelectEntityState) => string | number | undefined;
+    selectEntitySelected: (state: LoadEntitiesState<T> & SelectEntityState) => T | undefined;
+};
+export declare type SelectEntityMutators<T> = {
+    selectEntity<S extends LoadEntitiesState<T> & SelectEntityState>(id: string | number, state: S): S;
+    deselectEntity<S extends LoadEntitiesState<T> & SelectEntityState>(state: S): S;
+    toggleSelectEntity<S extends LoadEntitiesState<T> & SelectEntityState>(id: string | number, state: S): S;
+};
+export interface SelectEntityConfig {
+    selectedId?: string | number;
+}
+export declare const selectEntityTraitKey = "singleSelection";
+export declare type SelectEntityKeyedConfig = KeyedConfig<typeof selectEntityTraitKey, SelectEntityConfig>;

package/select-entity/select-entity.trait.actions.d.ts

@@ -0,0 +1,2 @@
+import { SelectEntityActions } from './select-entity.model';
+export declare function createSelectEntityTraitActions(actionsGroupKey: string, entityName: string): SelectEntityActions;

package/select-entity/select-entity.trait.d.ts

@@ -0,0 +1,30 @@
+import { SelectEntityActions, SelectEntityConfig } from './select-entity.model';
+/**
+ * Generates ngrx code to add single selection to a list
+ * @param config
+ * @param config.selectedId - Default selected id
+ *
+ * @example
+ * // The following trait config
+ *
+ * export interface TestState
+ * extends EntityAndStatusState<Todo>,SelectEntityState{}
+ *
+ *    const traits = createEntityFeatureFactory(
+ *      addLoadEntitiesTrait<Todo>(),
+ *      addSelectEntityTrait<Todo>()
+ *    )({
+ *      actionsGroupKey: '[Todos]',
+ *      featureSelector: createFeatureSelector<TestState>>(
+ *        'todos',
+ *      ),
+ *    });
+ * // will generate  the following actions and selectors, plus the ones generated by other traits
+ * traits.actions.selectTodo({id})
+ * traits.actions.deselectTodo()
+ * traits.actions.toggleSelectTodo({id})
+ *
+ * traits.selectors.selectTodoIdSelected()
+ * traits.selectors.selectTodoSelected()
+ */
+export declare function addSelectEntityTrait<Entity>(config?: SelectEntityConfig): import("@ngrx-traits/core").TraitFactory<import("../load-entities/load-entities.model").LoadEntitiesState<Entity> & import("./select-entity.model").SelectEntityState, SelectEntityActions, import("./select-entity.model").SelectEntitySelectors<Entity>, import("./select-entity.model").SelectEntityMutators<unknown>, "singleSelection", SelectEntityConfig, import("@ngrx-traits/core").AllTraitConfigs>;

package/select-entity/select-entity.trait.mutators.d.ts

@@ -0,0 +1,2 @@
+import { SelectEntityMutators } from './select-entity.model';
+export declare function createSelectEntityTraitMutators<Entity>(): SelectEntityMutators<Entity>;

package/select-entity/select-entity.trait.reducer.d.ts

@@ -0,0 +1,8 @@
+import { LoadEntitiesActions, LoadEntitiesKeyedConfig, LoadEntitiesState } from '../load-entities/load-entities.model';
+import { SortEntitiesActions, SortEntitiesKeyedConfig } from '../sort-entities/sort-entities.model';
+import { SelectEntityActions, SelectEntityKeyedConfig, SelectEntityMutators, SelectEntityState } from './select-entity.model';
+import { CrudEntitiesActions } from '../crud-entities/crud-entities.model';
+import { EntitiesPaginationActions, EntitiesPaginationKeyedConfig } from '../entities-pagination/entities-pagination.model';
+import { FilterEntitiesActions } from '../filter-entities';
+export declare function createSelectEntityInitialState<Entity>(previousInitialState: any, allConfigs: SelectEntityKeyedConfig): LoadEntitiesState<Entity> & SelectEntityState;
+export declare function createSelectEntityTraitReducer<Entity, S extends LoadEntitiesState<Entity> & SelectEntityState>(initialState: S, allActions: SelectEntityActions & CrudEntitiesActions<Entity> & SortEntitiesActions<Entity> & EntitiesPaginationActions & FilterEntitiesActions<any> & LoadEntitiesActions<Entity>, allMutators: SelectEntityMutators<Entity>, allConfigs: SelectEntityKeyedConfig & LoadEntitiesKeyedConfig<Entity> & EntitiesPaginationKeyedConfig & SortEntitiesKeyedConfig<Entity>): import("@ngrx/store").ActionReducer<S, import("@ngrx/store").Action>;

package/select-entity/select-entity.trait.selectors.d.ts

@@ -0,0 +1,2 @@
+import { SelectEntitySelectors } from './select-entity.model';
+export declare function createSelectEntityTraitSelectors<Entity>(): SelectEntitySelectors<Entity>;

package/set-entity/index.d.ts

@@ -0,0 +1,2 @@
+export * from './set-entity.model';
+export * from './set-entity.trait';

package/set-entity/set-entity.model.d.ts

@@ -0,0 +1,16 @@
+import { PostfixProps } from '@ngrx-traits/core';
+import { ActionCreator, TypedAction } from '@ngrx/store/src/models';
+declare type SetActions<T> = {
+    /**
+     * set entity in the store
+     */
+    set: ActionCreator<string, (props: T) => TypedAction<string>>;
+};
+export declare type SetEntityActions<Entity, J extends string> = PostfixProps<SetActions<Entity>, J>;
+export declare type SetEntityState<Entity, J extends string> = {
+    [key in `${J}`]?: Entity;
+};
+export declare type SetEntitySelectors<Entity, J extends string> = PostfixProps<{
+    select: (state: SetEntityState<Entity, J>) => Entity;
+}, J>;
+export {};

package/set-entity/set-entity.trait.d.ts

@@ -0,0 +1,39 @@
+import { SetEntityState } from './set-entity.model';
+import { ActionCreatorProps } from '@ngrx/store/src/models';
+declare type RecordEntity<T> = T extends Record<string, infer J> ? J : never;
+/**
+ * Generates ngrx code needed to set and entity in the store state
+ * @param entityName - Entity name, should be in camel case
+ * @param options.actionProps - param for the main request action,
+ * use the props() function for its value
+ * @returns the trait factory
+ *
+ * @example
+ * const traits = createEntityFeatureFactory(
+ * addSetEntityTraits({
+ *        entityName: 'client',
+ *        actionProps: props<{ client: { id: number; name: string } }
+ *      }),
+ * )({
+ *      actionsGroupKey: 'Client',
+ *      featureSelector: createFeatureSelector<
+ *        SetEntityState<Client, 'client'>
+ *        >('client'),
+ *    });
+ *
+ * // will generate
+ * traits.actions.setClient({client: {id:123, name: 'gabs'}});
+ * traits.selectors.selectClient
+ */
+export declare function addSetEntityTrait<J extends string, Payload extends Record<J, any> | undefined = undefined, Entity = RecordEntity<Payload>, State = SetEntityState<Entity, J>>({ entityName, actionProps, }: {
+    entityName: J;
+    actionProps?: ActionCreatorProps<Payload>;
+}): import("@ngrx-traits/core").TraitFactory<State, import("@ngrx-traits/core").PostfixProps<{
+    set: import("@ngrx/store").ActionCreator<string, (props: Payload) => import("@ngrx/store/src/models").TypedAction<string>>;
+}, J>, import("@ngrx-traits/core").PostfixProps<{
+    select: (state: SetEntityState<Entity, J>) => Entity;
+}, J>, {}, string, {
+    entityName: J;
+    actionProps: ActionCreatorProps<Payload> | undefined;
+}, import("@ngrx-traits/core").AllTraitConfigs>;
+export {};

package/sort-entities/index.d.ts

@@ -0,0 +1,3 @@
+export * from './sort-entities.model';
+export * from './sort-entities.trait';
+export * from './sort-entities.utils';