@ngrx-traits/common 19.2.2 → 20.0.0-beta.1

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@ngrx-traits/common",
-  "version": "19.2.2",
+  "version": "20.0.0-beta.1",
   "peerDependencies": {
     "@angular/core": "^19.0.0",
     "@ngrx/effects": "^19.0.0",
     "@ngrx/entity": "^19.0.0",
     "@ngrx/store": "^19.0.0",
-    "@ngrx-traits/core": "19.2.2"
+    "@ngrx-traits/core": "20.0.0-beta.1"
   },
   "optionalDependencies": {
     "@angular/router": "^19.0.0"

package/async-action/async-action.model.d.ts

@@ -1,19 +0,0 @@
-import { PostfixProps, PrefixProps } from '@ngrx-traits/core';
-import { ActionCreator, NotAllowedCheck } from '@ngrx/store';
-import { Action } from '@ngrx/store/src/models';
-import { StatusState } from '../load-entities';
-export type ActionCreatorWithOptionalProps<T> = T extends undefined ? ActionCreator<string, () => Action<string>> : ActionCreator<string, (props: T & NotAllowedCheck<T & object>) => T & Action<string>>;
-type AsyncActions<Request, Response, Failure> = {
-    '': ActionCreatorWithOptionalProps<Request>;
-    Success: ActionCreatorWithOptionalProps<Response>;
-    Fail: ActionCreatorWithOptionalProps<Failure>;
-};
-type StatusSelectors<S extends StatusState> = {
-    isLoading: (state: S) => boolean;
-    isSuccess: (state: S) => boolean;
-    isFail: (state: S) => boolean;
-};
-export type AsyncActionState<J extends string> = PrefixProps<StatusState, J>;
-export type AsyncActionSelectors<J extends string, S extends StatusState> = PostfixProps<StatusSelectors<S>, J>;
-export type AsyncActionActions<Request, Response, Failure, J extends string> = PrefixProps<AsyncActions<Request, Response, Failure>, J>;
-export {};

package/async-action/async-action.trait.d.ts

@@ -1,68 +0,0 @@
-import { ActionCreatorProps } from '@ngrx/store/src/models';
-import { ActionCreatorWithOptionalProps } from './async-action.model';
-/**
- * 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
- *
- * export interface TestState
- * extends AsyncActionState<'createClient'>{}
- *
- * // 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 declare function addAsyncActionTrait<J extends string, Request extends object | undefined = undefined, Response extends object | undefined = undefined, Failure extends object | undefined = undefined>({ name, actionProps, actionSuccessProps, actionFailProps, }: {
-    name: J;
-    actionProps?: ActionCreatorProps<Request>;
-    actionSuccessProps?: ActionCreatorProps<Response>;
-    actionFailProps?: ActionCreatorProps<Failure>;
-}): import("@ngrx-traits/core").TraitFactory<import("@ngrx-traits/core").PrefixProps<import("@ngrx-traits/common").StatusState, J>, import("@ngrx-traits/core").PrefixProps<{
-    '': ActionCreatorWithOptionalProps<Request>;
-    Success: ActionCreatorWithOptionalProps<Response>;
-    Fail: ActionCreatorWithOptionalProps<Failure>;
-}, J>, import("@ngrx-traits/core").PostfixProps<{
-    isLoading: (state: import("@ngrx-traits/core").PrefixProps<import("@ngrx-traits/common").StatusState, J>) => boolean;
-    isSuccess: (state: import("@ngrx-traits/core").PrefixProps<import("@ngrx-traits/common").StatusState, J>) => boolean;
-    isFail: (state: import("@ngrx-traits/core").PrefixProps<import("@ngrx-traits/common").StatusState, J>) => boolean;
-}, J>, {}, string, {
-    name: J;
-    actionProps: ActionCreatorProps<Request> | undefined;
-    actionSuccessProps: ActionCreatorProps<Response> | undefined;
-    actionFailProps: ActionCreatorProps<Failure> | undefined;
-}, import("@ngrx-traits/core").AllTraitConfigs>;

package/async-action/index.d.ts

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

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

@@ -1,74 +0,0 @@
-import { Predicate, Update } from '@ngrx/entity/src/models';
-import { ActionCreator } from '@ngrx/store';
-import { Action } from '@ngrx/store/src/models';
-import { LoadEntitiesState } from '../load-entities/load-entities.model';
-export declare enum ChangeType {
-    CREATED = "c",
-    UPDATED = "u",
-    DELETED = "d"
-}
-export interface Change<T> {
-    id: string | number;
-    changeType: ChangeType;
-    entityChanges?: Partial<T>;
-}
-export interface EntityChange<T> {
-    entity: T;
-    changeType: ChangeType;
-}
-export interface CrudEntitiesState<T> {
-    changes: Change<T>[];
-}
-export type CrudEntitiesActions<T> = {
-    addEntities: ActionCreator<string, (...entities: T[]) => {
-        entities: T[];
-    } & Action<string>>;
-    removeEntities: ActionCreator<string, (...keys: string[] | number[]) => {
-        keys: string[] | number[];
-    } & Action<string>>;
-    updateEntities: ActionCreator<string, (...updates: Update<T>[]) => {
-        updates: Update<T>[];
-    } & Action<string>>;
-    upsertEntities: ActionCreator<string, (...entities: T[]) => {
-        entities: T[];
-    } & Action<string>>;
-    removeAllEntities: ActionCreator<string, (predicate?: Predicate<T>) => {
-        predicate?: Predicate<T>;
-    } & Action<string>>;
-    clearEntitiesChanges: ActionCreator<string, () => Action<string>>;
-};
-export type CrudEntitiesSelectors<Entity> = {
-    /**
-     * Return all changes made to the list plus entities, and can be filtered
-     * by change type
-     * @param state
-     * @param props
-     */
-    selectEntitiesChangesList: (state: LoadEntitiesState<Entity> & CrudEntitiesState<Entity>) => EntityChange<Entity>[];
-    /**
-     * Returns the entities plus the kind of change,
-     * filters redundant changes ideal for a batch update
-     * if you add and remove the same and items this changes are remove from the list
-     * if you add and then update one or more times, the updates are discarded
-     * if you update one or more times and then remove, the updates are discarded
-     * @param state
-     */
-    selectFilteredEntitiesChangesList: (state: LoadEntitiesState<Entity> & CrudEntitiesState<Entity>) => EntityChange<Entity>[];
-};
-export type CrudEntitiesMutators<Entity> = {
-    addEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(entities: Entity[], state: S): S;
-    removeEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(keys: string[], state: S): S;
-    removeEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(keys: number[], state: S): S;
-    removeEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(predicate: Predicate<Entity>, state: S): S;
-    removeAllEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(state: S): S;
-    clearEntitiesChanges<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(state: S): S;
-    updateEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(updates: Update<Entity>[], state: S): S;
-    upsertEntities<S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(entities: Entity[], state: S): S;
-};
-export interface CrudEntitiesConfig {
-    storeChanges?: boolean;
-}
-export declare const crudEntitiesTraitKey = "crud";
-export interface CrudEntitiesKeyedConfig {
-    crud?: CrudEntitiesConfig;
-}

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

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

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

@@ -1,40 +0,0 @@
-import { CrudEntitiesActions, CrudEntitiesConfig } from './crud-entities.model';
-/**
- * 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(
- *      {entityName: 'Todo'},
- *      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 declare function addCrudEntitiesTrait<Entity>({ storeChanges, }?: CrudEntitiesConfig): import("@ngrx-traits/core").TraitFactory<import("../load-entities/load-entities.model").LoadEntitiesState<Entity> & import("./crud-entities.model").CrudEntitiesState<Entity>, CrudEntitiesActions<Entity>, import("./crud-entities.model").CrudEntitiesSelectors<Entity>, import("./crud-entities.model").CrudEntitiesMutators<Entity>, "crud", CrudEntitiesConfig, import("@ngrx-traits/core").AllTraitConfigs>;

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

@@ -1,3 +0,0 @@
-import { CrudEntitiesKeyedConfig, CrudEntitiesMutators } from './crud-entities.model';
-import { LoadEntitiesKeyedConfig } from '../load-entities/load-entities.model';
-export declare function createCrudTraitMutators<Entity>(allConfigs: CrudEntitiesKeyedConfig & LoadEntitiesKeyedConfig<Entity>): CrudEntitiesMutators<Entity>;

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

@@ -1,7 +0,0 @@
-import { FilterEntitiesActions, FilterEntitiesKeyedConfig } from '../filter-entities/filter-entities.model';
-import { CrudEntitiesActions, CrudEntitiesKeyedConfig, CrudEntitiesMutators, CrudEntitiesState } from './crud-entities.model';
-import { LoadEntitiesActions, LoadEntitiesKeyedConfig, LoadEntitiesState } from '../load-entities';
-import { SortEntitiesActions, SortEntitiesKeyedConfig } from '../sort-entities';
-import { EntitiesPaginationActions, EntitiesPaginationKeyedConfig } from '../entities-pagination';
-export declare function createCrudInitialState<Entity>(previousInitialState: any): LoadEntitiesState<Entity> & CrudEntitiesState<Entity>;
-export declare function createCrudTraitReducer<Entity, S extends LoadEntitiesState<Entity> & CrudEntitiesState<Entity>>(initialState: S, allActions: CrudEntitiesActions<Entity> & LoadEntitiesActions<Entity> & SortEntitiesActions<Entity> & FilterEntitiesActions<any> & EntitiesPaginationActions, allMutators: CrudEntitiesMutators<Entity>, allConfigs: CrudEntitiesKeyedConfig & FilterEntitiesKeyedConfig<Entity, unknown> & LoadEntitiesKeyedConfig<Entity> & SortEntitiesKeyedConfig<Entity> & EntitiesPaginationKeyedConfig): import("@ngrx/store").ActionReducer<unknown extends S ? S : S, import("@ngrx/store").Action<string>>;

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

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

package/crud-entities/index.d.ts

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

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

@@ -1,80 +0,0 @@
-import { Action, ActionCreator } from '@ngrx/store/src/models';
-import { LoadEntitiesState } from '../load-entities';
-export type CacheType = 'full' | 'partial' | 'grow';
-export interface EntitiesPaginationState {
-    pagination: {
-        currentPage: number;
-        requestPage: number;
-        pageSize: number;
-        total?: number;
-        pagesToCache: number;
-        cache: {
-            type: CacheType;
-            start: number;
-            end: number;
-        };
-    };
-}
-export type EntitiesPaginationActions = {
-    loadEntitiesPage: ActionCreator<string, (props: {
-        index: number;
-        forceLoad?: boolean;
-    }) => {
-        index: number;
-        forceLoad?: boolean;
-    } & Action<string>>;
-    loadEntitiesPageSuccess: ActionCreator<string, () => Action<string>>;
-    loadEntitiesPageFail: ActionCreator<string, () => Action<string>>;
-    loadEntitiesNextPage: ActionCreator<string, () => Action<string>>;
-    loadEntitiesPreviousPage: ActionCreator<string, () => Action<string>>;
-    loadEntitiesFirstPage: ActionCreator<string, (forceLoad?: boolean) => {
-        forceLoad?: boolean;
-    } & Action<string>>;
-    loadEntitiesLastPage: ActionCreator<string, () => Action<string>>;
-    clearEntitiesPagesCache: ActionCreator<string, () => Action<string>>;
-};
-export type EntitiesPaginationSelectors<T> = {
-    selectEntitiesCurrentPageList: (state: LoadEntitiesState<T> & EntitiesPaginationState) => T[];
-    selectEntitiesCurrentPage: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PageModel<T>;
-    selectEntitiesPagedRequest: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PagedRequest;
-    selectEntitiesCurrentPageInfo: (state: LoadEntitiesState<T> & EntitiesPaginationState) => PageInfoModel;
-    isLoadingEntitiesCurrentPage: (state: LoadEntitiesState<T> & EntitiesPaginationState) => boolean;
-};
-export type EntitiesPaginationMutators<Entity> = {
-    mergePaginatedEntities<S extends LoadEntitiesState<Entity> & EntitiesPaginationState>(entities: Entity[], total: number | undefined, state: S): S;
-    setEntitiesPage<Entity, S extends LoadEntitiesState<Entity> & EntitiesPaginationState>(state: S, index: number): S;
-};
-export interface PageModel<T> {
-    entities: T[];
-    isLoading: boolean;
-    pageIndex: number;
-    total: number | undefined;
-    pageSize: number;
-    pagesCount: number | undefined;
-    hasPrevious: boolean;
-    hasNext: boolean;
-}
-export interface PageInfoModel {
-    pageIndex: number;
-    total: number | undefined;
-    pageSize: number;
-    pagesCount: number | undefined;
-    hasPrevious: boolean;
-    hasNext: boolean;
-    cacheType: CacheType;
-}
-export interface PagedRequest {
-    startIndex: number;
-    size: number;
-    page: number;
-}
-export declare const entitiesPaginationTraitKey = "pagination";
-export interface EntitiesPaginationConfig {
-    cacheType?: CacheType;
-    pageSize?: number;
-    currentPage?: number;
-    pagesToCache?: number;
-}
-export interface EntitiesPaginationKeyedConfig {
-    pagination?: EntitiesPaginationConfig;
-}

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

@@ -1,20 +0,0 @@
-import { Action, ActionCreator } from '@ngrx/store/src/models';
-import { LoadEntitiesState } from '../load-entities/load-entities.model';
-import { EntitiesPaginationActions, EntitiesPaginationSelectors, EntitiesPaginationState } from './entities-pagination.model';
-/**
- * @internal
- */
-export type ƟPaginationActions = EntitiesPaginationActions & {
-    setEntitiesRequestPage: ActionCreator<string, (props: {
-        index: number;
-    }) => {
-        index: number;
-    } & Action<string>>;
-};
-/**
- * @internal
- */
-export type ƟEntitiesPaginationSelectors<Entity> = EntitiesPaginationSelectors<Entity> & {
-    isEntitiesCurrentPageInCache: (state: LoadEntitiesState<Entity> & EntitiesPaginationState) => boolean;
-    isEntitiesNextPageInCache: (state: LoadEntitiesState<Entity> & EntitiesPaginationState) => boolean;
-};

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

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

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

@@ -1,69 +0,0 @@
-import { EntitiesPaginationConfig, EntitiesPaginationMutators, EntitiesPaginationSelectors } from './entities-pagination.model';
-/**
- * Generates ngrx code to paginate a list of entities, this has 3 cache `cacheType`
- * - 'full': The full result is cache in memory and split in pages to render, useful
- * for small result but not so small that requires been render in pages
- * - 'partial': Backend returns partial results because is are to big, this has a cache a few pages forward
- * to avoid calling the backend on each page, the cache is clean when a new loadEntities is required
- * - 'grow': Similar to partial that the backend returns partial result, but in this case the cache grows,
- * after each loadEntities the cache is appended to the previous cache, this mode is ideal for infinite scrolls,
- * where you will only call loadNextPage.
- * To make the pagination experience smoother the loadEntities action is fired when the current page is equal
- * to the last cached page, so while the user is reading the page more pages are being loading in the background.
- * @param config
- * @param config.cacheType - Default to 'partial', change the cache mode
- * @param config.pageSize - Default to 10, number of entities on  each page
- * @param config.currentPage - Default to 0, starting page
- * @param config.pagesToCache - Default to 3, used in partial and grow cache mode, is the number of
- * extra pages kept in cache to avoid calling the backend on each page
- *
- * @example
- * // The following trait config
- *
- * export interface TestState
- * extends EntityAndStatusState<Todo>,EntitiesPaginationState{}
- *
- *    const traits = createEntityFeatureFactory(
- *      {entityName: 'Todo'},
- *      addLoadEntitiesTrait<Todo>(),
- *      addEntitiesPaginationTrait<Todo>()
- *    )({
- *      actionsGroupKey: '[Todos]',
- *      featureSelector: createFeatureSelector<TestState>>(
- *        'todos',
- *      ),
- *    });
- *
- * //   adds following props to the state:
- * //    pagination: {
- * //       currentPage: number;
- * //       requestPage: number;
- * //       pageSize: number;
- * //       total?: number;
- * //       pagesToCache: number;
- * //       cache: {
- * //         type: 'full' | 'partial' | 'grow';
- * //         start: number;
- * //         end: number;
- * //       }
- * //     }
- *
- * // generated actions
- * traits.actions.loadTodosPage({index})
- * traits.actions.loadTodosPageSuccess()
- * traits.actions.loadTodosPageFail()
- * traits.actions.loadTodosNextPage()
- * traits.actions.loadTodosPreviousPage()
- * traits.actions.loadTodosFirstPage()
- * traits.actions.loadTodosLastPage()
- * traits.actions.clearTodosPagesCache()
- * // generated selectors
- * 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.selectTodosCurrentPage()
- * traits.selectors.selectTodosPagedRequest()// use in effects to get paging parameter
- * 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>, EntitiesPaginationMutators<Entity>, "pagination", EntitiesPaginationConfig, import("@ngrx-traits/core").AllTraitConfigs>;

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

@@ -1,8 +0,0 @@
-import { TraitEffect } from '@ngrx-traits/core';
-import { Type } from '@ngrx-traits/core';
-import { CrudEntitiesActions } from '../crud-entities/crud-entities.model';
-import { FilterEntitiesActions } from '../filter-entities/filter-entities.model';
-import { LoadEntitiesActions, LoadEntitiesSelectors } from '../load-entities';
-import { EntitiesPaginationSelectors } from './entities-pagination.model';
-import { ƟPaginationActions } from './entities-pagination.model.internal';
-export declare function createPaginationTraitEffects<Entity>(allActions: ƟPaginationActions & FilterEntitiesActions<Entity> & LoadEntitiesActions<Entity> & CrudEntitiesActions<Entity>, allSelectors: LoadEntitiesSelectors<Entity> & EntitiesPaginationSelectors<Entity>): Type<TraitEffect>[];

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

@@ -1,3 +0,0 @@
-import { EntitiesPaginationMutators, EntitiesPaginationSelectors } from './entities-pagination.model';
-import { LoadEntitiesKeyedConfig } from '../load-entities';
-export declare function createPaginationTraitMutators<Entity>(allSelectors: EntitiesPaginationSelectors<Entity>, allConfigs: LoadEntitiesKeyedConfig<Entity>): EntitiesPaginationMutators<Entity>;

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

@@ -1,8 +0,0 @@
-import { FilterEntitiesKeyedConfig } from '../filter-entities/filter-entities.model';
-import { LoadEntitiesActions, LoadEntitiesKeyedConfig, LoadEntitiesMutators, LoadEntitiesSelectors, LoadEntitiesState } from '../load-entities/load-entities.model';
-import { EntitiesPaginationKeyedConfig, EntitiesPaginationMutators, EntitiesPaginationState } from './entities-pagination.model';
-import { CrudEntitiesActions } from '../crud-entities';
-import { ƟPaginationActions } from './entities-pagination.model.internal';
-import { ƟFilterEntitiesActions } from '../filter-entities/filter-entities.model.internal';
-export declare function createPaginationInitialState<Entity>(previousInitialState: any, allConfigs: EntitiesPaginationKeyedConfig): LoadEntitiesState<Entity> & EntitiesPaginationState;
-export declare function createPaginationTraitReducer<Entity, S extends LoadEntitiesState<Entity> & EntitiesPaginationState>(initialState: S, allActions: ƟPaginationActions & ƟFilterEntitiesActions<Entity> & LoadEntitiesActions<Entity> & CrudEntitiesActions<Entity>, allSelectors: LoadEntitiesSelectors<Entity>, allMutators: EntitiesPaginationMutators<Entity> & LoadEntitiesMutators<Entity>, allConfigs: FilterEntitiesKeyedConfig<Entity, unknown> & LoadEntitiesKeyedConfig<Entity> & EntitiesPaginationKeyedConfig): import("@ngrx/store").ActionReducer<unknown extends S ? S : S, import("@ngrx/store").Action<string>>;

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

@@ -1,4 +0,0 @@
-import { EntitiesPaginationSelectors } from './entities-pagination.model';
-import { LoadEntitiesSelectors } from '../load-entities/load-entities.model';
-import { FilterEntitiesKeyedConfig } from '../filter-entities/filter-entities.model';
-export declare function createPaginationTraitSelectors<Entity>(previousSelectors: LoadEntitiesSelectors<Entity>, allConfigs: FilterEntitiesKeyedConfig<Entity, unknown>): EntitiesPaginationSelectors<Entity>;

package/entities-pagination/index.d.ts

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

package/entities-sync-to-route-query-params/entities-sync-to-route-query-params.d.ts

@@ -1,30 +0,0 @@
-import { Action, ActionCreator } from '@ngrx/store/src/models';
-/**
- * Generates ngrx code necessary to load and set to the current route query params for the filter, sort and paging traits
- *
- * @example
- *
- *    const traits = createEntityFeatureFactory(
- *      {entityName: 'Todo'},
- *      addLoadEntitiesTrait<Todo>(),
- *      addFilterEntitiesTrait(),
- *      addSortEntitiesTrait<Todo>({
- *        remote: true,
- *        defaultSort: {active:'id', direction:'asc'}
- *      })
- *      addEntitiesPaginationTrait<Todo>(),
- *      addEntitiesSyncToRouteQueryParams()
- *    )({
- *      actionsGroupKey: '[Todos]',
- *      featureSelector: createFeatureSelector<TestState>>(
- *        'todos',
- *      ),
- *    });
- *
- *
- * // generated actions
- * traits.actions.loadTodosUsingRouteQueryParams()
- */
-export declare function addEntitiesSyncToRouteQueryParams(): import("@ngrx-traits/core").TraitFactory<{}, {
-    loadEntitiesUsingRouteQueryParams: ActionCreator<`${string} Load ${string} Using Route Query Params`, () => Action<`${string} Load ${string} Using Route Query Params`>>;
-}, {}, {}, "entitiesSyncToRouteQueryParams", unknown, import("@ngrx-traits/core").AllTraitConfigs>;

package/entities-sync-to-route-query-params/index.d.ts

@@ -1 +0,0 @@
-export * from './entities-sync-to-route-query-params';

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

@@ -1,57 +0,0 @@
-import { Action, ActionCreator } from '@ngrx/store/src/models';
-import { LoadEntitiesState } from '../load-entities/load-entities.model';
-export interface FilterEntitiesState<F> {
-    filters?: F;
-}
-type FilterPatchConditionalType<F, P> = P extends true ? Partial<F> : F;
-export interface FilterActionOverload<F> {
-    <P extends boolean>(props?: {
-        filters: FilterPatchConditionalType<F, P>;
-        forceLoad?: boolean;
-        patch: P;
-    }): {
-        filters: FilterPatchConditionalType<F, P>;
-        forceLoad: boolean;
-        patch: P;
-    } & Action<string>;
-    (props?: {
-        filters: F;
-        forceLoad?: boolean;
-    }): {
-        filters: F;
-        forceLoad: boolean;
-        patch: boolean;
-    } & Action<string>;
-}
-export type FilterEntitiesActions<F> = {
-    /**
-     * Store the filters param (read using selectFilter) and fires the loadEntities action
-     * if the filters param has changed, this call is also debounce by default, to disable this
-     * behavior you can use the forceLoad param as true or defaultDebounceTime to 0 in the trait config
-     * to disable permanently.
-     * If the `patch` param is set to true (default is false), the filters are merged with the previous value in the store,
-     * otherwise they are replaced.
-     */
-    filterEntities: ActionCreator<string, FilterActionOverload<F>>;
-};
-export type FilterEntitiesSelectors<T, F> = {
-    /**
-     * Returns the stored filters set by the filter action
-     * @param state
-     */
-    selectEntitiesFilter: (state: LoadEntitiesState<T> & FilterEntitiesState<F>) => F | undefined;
-};
-export type FilterEntitiesMutators<T, F> = {
-    setEntitiesFilters<S extends LoadEntitiesState<T> & FilterEntitiesState<F>>(filter: F | undefined, state: S): S;
-};
-export declare const filterEntitiesTraitKey = "filter";
-export type FilterEntitiesConfig<T, F> = {
-    defaultFilter?: F;
-    filterFn?: (filter: F, entity: T) => boolean;
-    defaultDebounceTime?: number;
-    isRemoteFilter?: (previous: F | undefined, current: F | undefined) => boolean;
-};
-export type FilterEntitiesKeyedConfig<T, F> = {
-    filter?: FilterEntitiesConfig<T, F>;
-};
-export {};

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

@@ -1,14 +0,0 @@
-import { Action, ActionCreator } from '@ngrx/store/src/models';
-import { FilterEntitiesActions } from './filter-entities.model';
-/**
- * @internal
- */
-export type ƟFilterEntitiesActions<F> = FilterEntitiesActions<F> & {
-    storeEntitiesFilter: ActionCreator<string, (props: {
-        filters?: F;
-        patch?: boolean;
-    }) => {
-        filters?: F;
-        patch?: boolean;
-    } & Action<string>>;
-};

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

@@ -1,2 +0,0 @@
-import { FilterEntitiesActions } from './filter-entities.model';
-export declare function createFilterTraitActions<F>(actionsGroupKey: string, entitiesName: string): FilterEntitiesActions<F>;

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

@@ -1,48 +0,0 @@
-import { FilterEntitiesConfig, FilterEntitiesSelectors } from './filter-entities.model';
-/**
- * Generates the ngrx code needed to filter a list of entities locally or remotely, adds a filter
- * action and a selectFilter selector, the filter action is debounced and the filter will only
- * call the loadEntities action if the params have changed, so there is no need to implement that in
- * the components. The filter action has a `forceLoad` param which can
- * be use to skip that restriction for one call or setting the `defaultDebounceTime` to 0 for all calls.
- * Calling the filter action will also replace the `filters` param in the store, if the `patch` param is set
- * the filters are merged with the previous value in the store.
- * @param traitConfig - Config object fot the trait factory
- * @param traitConfig.defaultFilter - Initial value for the filter
- * @param traitConfig.filterFn - Function to filter entities in memory, if not present then its expected
- * is filtered by the backend unless isRemoteFilter is defned
- * @param traitConfig.defaultDebounceTime - Value in milliseconds. Default to 400ms
- * @param traitConfig.isRemoteFilter - Function to when it returns true it fires loadEntities so a remote
- * backend filtering can run, otherwise it uses filterFn to do a local filtering
- *
- * @example
- * // The following trait config
- *
- * export interface TestState
- * extends LoadEntitiesState<Todo>, FilterEntitiesState<TodoFilter>{}
- *
- *    const traits = createEntityFeatureFactory(
- *      {entityName: 'Todo'},
- *      addLoadEntitiesTrait<Todo>(),
- *      //addFilterEntitiesTrait<Todo,TodoFilter>() // no params uses remote filtering
- *      addFilterEntitiesTrait<Todo,TodoFilter>({filterFn: (filter, entity) => // local filtering
- *          !filter.content || !!entity.content?.includes(filter.content.toLowerCase())
- *          // or use the following function to switch between remote search and local
- *          // depending on which properties have changed in the filter
- *          // isRemoteFilter: (previous, current) => previous?.someRemoteParam !== current?.someRemoteParam,
- *    )({
- *      actionsGroupKey: '[Todos]',
- *      featureSelector: createFeatureSelector<TestState>>(
- *        'todos',
- *      ),
- *    });
- *
- * //   adds following props to the state:
- * //    filters?: TodoFilter;
- *
- * // generated actions
- * traits.actions.filterTodos()
- * // generated selectors
- * traits.selectors.selectTodosFilter()
- */
-export declare function addFilterEntitiesTrait<Entity, F>({ defaultDebounceTime, defaultFilter, filterFn, isRemoteFilter, }?: FilterEntitiesConfig<Entity, F>): import("@ngrx-traits/core").TraitFactory<import("../load-entities/load-entities.model").LoadEntitiesState<Entity> & import("./filter-entities.model").FilterEntitiesState<F>, import("./filter-entities.model").FilterEntitiesActions<F>, FilterEntitiesSelectors<Entity, F>, import("./filter-entities.model").FilterEntitiesMutators<Entity, F>, "filter", FilterEntitiesConfig<Entity, F>, import("@ngrx-traits/core").AllTraitConfigs>;

package/filter-entities/filter-entities.trait.effect.d.ts

@@ -1,6 +0,0 @@
-import { TraitEffect, Type } from '@ngrx-traits/core';
-import { EntitiesPaginationActions } from '../entities-pagination';
-import { LoadEntitiesActions, LoadEntitiesSelectors } from '../load-entities/load-entities.model';
-import { FilterEntitiesKeyedConfig, FilterEntitiesSelectors } from './filter-entities.model';
-import { ƟFilterEntitiesActions } from './filter-entities.model.internal';
-export declare function createFilterTraitEffects<Entity, F>(allActions: ƟFilterEntitiesActions<F> & LoadEntitiesActions<Entity> & EntitiesPaginationActions, allSelectors: FilterEntitiesSelectors<Entity, F> & LoadEntitiesSelectors<Entity>, allConfigs: FilterEntitiesKeyedConfig<Entity, F>): Type<TraitEffect>[];

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

@@ -1,2 +0,0 @@
-import { FilterEntitiesMutators } from './filter-entities.model';
-export declare function createFilterTraitMutators<Entity, F>(): FilterEntitiesMutators<Entity, F>;