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

package/cache/cache.models.d.ts

@@ -1,20 +0,0 @@
-export type CacheKey = string | (string | object)[];
-export interface CacheData {
-    value: any;
-    date: number;
-    invalid: boolean;
-    hitCount: number;
-}
-export interface CacheKeys {
-    keys?: {
-        [key: string]: CacheKeys;
-    };
-    data?: CacheData;
-}
-export type CacheState = CacheKeys;
-export interface CacheConfig {
-    expires: number;
-}
-export declare function hashKey(key: CacheKey): string[];
-export declare function getCacheValue(keys: string[], state: CacheState): CacheData | undefined;
-export declare function isCacheValid(cache: CacheData, exp: number): boolean;

package/cache/cache.module.d.ts

@@ -1,7 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "@ngrx/store";
-export declare class CacheModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<CacheModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CacheModule, never, [typeof i1.StoreFeatureModule], never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<CacheModule>;
-}

package/cache/cache.reducer.d.ts

@@ -1,3 +0,0 @@
-import { CacheKeys, CacheState } from './cache.models';
-export declare const initialState: CacheState;
-export declare const cacheReducer: import("@ngrx/store").ActionReducer<CacheKeys, import("@ngrx/store").Action<string>>;

package/cache/cache.selectors.d.ts

@@ -1,3 +0,0 @@
-import { CacheKey } from './cache.models';
-export declare const cacheStateSelector: import("@ngrx/store").MemoizedSelector<object, import("./cache.models").CacheKeys, import("@ngrx/store").DefaultProjectorFn<import("./cache.models").CacheKeys>>;
-export declare const selectCache: (key: CacheKey) => import("@ngrx/store").MemoizedSelector<object, import("./cache.models").CacheData | undefined, (s1: import("./cache.models").CacheKeys) => import("./cache.models").CacheData | undefined>;

package/cache/cache.service.d.ts

@@ -1,66 +0,0 @@
-import { Store } from '@ngrx/store';
-import { Observable } from 'rxjs';
-import { CacheKey } from './cache.models';
-/**
- * Cache the result of source parameter using the provided key, when call
- * again if the cache is valid (exist and is not expired or invalidated)
- * it will return the cache value without calling again source
- * @example
- * // cache for 3 min
- * loadStores$ = createEffect(() => {
- *   return this.actions$.pipe(
- *     ofType(ProductStoreActions.loadStores),
- *     exhaustMap(() =>
- *       cache({
- *         key: ['stores'],
- *         store: this.store,
- *         source: this.storeService.getStores(),
- *         expire: 1000 * 60 * 3 // optional param , cache forever if not present
- *       }).pipe(
- *         map((res) => ProductStoreActions.loadStoresSuccess({ entities: res })),
- *         catchError(() => of(ProductStoreActions.loadStoresFail()))
- *       )
- *     )
- *   );
- * });
- * // cache top 10, for 3 mins
- *   loadDepartments$ = createEffect(() => {
- *   return this.actions$.pipe(
- *     ofType(this.localActions.loadDepartments),
- *     concatLatestFrom(() =>
- *       this.store.select(this.localSelectors.selectDepartmentsFilter)
- *     ),
- *     exhaustMap(([_, filters]) =>
- *       cache({
- *         key: ['stores','departments',{ storeId: filters!.storeId },
- *         store: this.store,
- *         source: this.storeService.getStoreDepartments(filters!.storeId),
- *         expires: 1000 * 60 * 3,
- *         maxCacheSize: 10,
- *       }).pipe(
- *         map((res) =>
- *           this.localActions.loadDepartmentsSuccess({
- *             entities: res,
- *           })
- *         ),
- *         catchError(() => of(this.localActions.loadDepartmentsFail()))
- *       )
- *     )
- *   );
- * });
- *
- * @param options - configuration
- * @param options.store - required ngrx store
- * @param options.key - key can be string, array of string or array of string with plain objects
- * @param options.source - called when cache is invalid
- * @param options.expires - time to expire the cache valued, if not present is infinite
- * @param options.maxCacheSize - max number of keys to store , only works if last key is variable
- */
-export declare function cache<T>({ store, key, source, expires, maxCacheSize, skip, }: {
-    store: Store;
-    key: CacheKey;
-    source: Observable<T>;
-    expires?: number;
-    maxCacheSize?: number;
-    skip?: boolean;
-}): Observable<any>;

package/cache/index.d.ts

@@ -1,17 +0,0 @@
-export * from './cache.service';
-export * from './cache.module';
-export declare const CacheActions: {
-    invalidateCache: import("@ngrx/store").ActionCreator<"[Cache] Invalidate Cache", (props: {
-        key: import("./cache.models").CacheKey;
-    }) => {
-        key: import("./cache.models").CacheKey;
-    } & import("@ngrx/store").Action<"[Cache] Invalidate Cache">>;
-    deleteCache: import("@ngrx/store").ActionCreator<"[Cache] Delete Cache", (props: {
-        key: import("./cache.models").CacheKey;
-    }) => {
-        key: import("./cache.models").CacheKey;
-    } & import("@ngrx/store").Action<"[Cache] Delete Cache">>;
-};
-export declare const CacheSelectors: {
-    getCache: (key: import("./cache.models").CacheKey) => import("@ngrx/store").MemoizedSelector<object, import("./cache.models").CacheData | undefined, (s1: import("./cache.models").CacheKeys) => import("./cache.models").CacheData | undefined>;
-};

package/create-entity-feature.d.ts

@@ -1,250 +0,0 @@
-import { Config, ExtractActionsType, ExtractSelectorsType, ExtractStateType, EntityFeatureFactory, FeatureSelectors, KeyedConfig, TraitActions, TraitFactory, TraitSelectors, TraitStateMutators, UnionToIntersection, TraitActionsFactory, TraitSelectorsFactory, TraitInitialStateFactory, TraitStateMutatorsFactory, TraitReducerFactory, TraitEffectsFactory, AllTraitConfigs } from './model';
-import { ActionType, MemoizedSelector } from '@ngrx/store';
-import { Type } from './local-store';
-/**
- * Creates a function that when execute will combine all the traits, and return a EntityFeatureFactory
- * which combines all the traits actions, selectors , reducers and effects,
- * the names param will replace any action and selector with the word Entity or Entities,
- * with the corresponding entityName and  entitiesName param (entityName+'s' if entitiesName is omitted).
- * @param namesConfig - Optional Names for entities
- * @param namesConfig.entityName - singular name for entity
- * @param [namesConfig.entitiesName] - plural name for entities, defaults to entityName + 's'
- * @param traits set of traits to be combined
- *
- * @example
- *
- * const featureFactory = createEntityFeatureFactory(
- *   { entityName: 'product' },
- *   addLoadEntitiesTrait<Product>(),
- *   addSelectEntityTrait<Product>(),
- *   addAsyncActionTrait({
- *     name: 'checkout',
- *     actionSuccessProps: props<{ orderId: string }>(),
- *   })
- * );
- *
- * export const productsFeature = featureFactory({
- *   actionsGroupKey: '[Products]',
- *   featureSelector: 'products',
- * });
- */
-export declare function createEntityFeatureFactory<F extends readonly TraitFactory[], EntityName extends string, EntitiesName extends string = `${EntityName}s`>({ entityName, entitiesName, }: {
-    entityName: EntityName;
-    entitiesName?: EntitiesName;
-}, ...traits: F): EntityFeatureFactory<EntityName, EntitiesName, ExtractStateType<F>, ExtractActionsType<F>, ExtractSelectorsType<F>>;
-/**
- * Creates a function that when execute will combine all the traits, and return a EntityFeatureFactory
- * which combines all the traits actions, selectors , reducers and effects.
- * @param traits set of traits to be combined
- *
- * @example
- *
- * const featureFactory = createEntityFeatureFactory(
- *   { entityName: 'product' },
- *   addLoadEntitiesTrait<Product>(),
- *   addSelectEntityTrait<Product>(),
- *   addAsyncActionTrait({
- *     name: 'checkout',
- *     actionSuccessProps: props<{ orderId: string }>(),
- *   })
- * );
- *
- * export const productsFeature = featureFactory({
- *   actionsGroupKey: '[Products]',
- *   featureSelector: 'products',
- * });
- *
- * productsFeature.actions.loadProducts();
- */
-export declare function createEntityFeatureFactory<F extends readonly TraitFactory[]>(...traits: F): EntityFeatureFactory<'Entity', 'Entities', ExtractStateType<F>, ExtractActionsType<F>, ExtractSelectorsType<F>>;
-/**
- * Combine a map entityFeatureFactories into one,
- * grouping the actions and selectors by the key of the respective entityFeatureFactory
- * @param traitFactoriesMap
- *
- * @example
- *
- * const clientsFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'client', entitiesName: 'clients' },
- *   addLoadEntitiesTrait<Client>(),
- *   addCrudEntitiesTrait<Client>()
- * );
- *
- * const productOrderFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'productOrder' },
- *   addLoadEntitiesTrait<ProductOrder>(),
- *   addSelectEntitiesTrait<ProductOrder>()
- * );
- *
- * const productFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'product' },
- *   addLoadEntitiesTrait<Product>(),
- *   addSelectEntitiesTrait<Product>()
- * );
- *
- * const productCombinedFactory = combineEntityFeatures({
- *   products: productFeatureFactory,
- *   productOrders: productOrderFeatureFactory,
- *   clients: clientsFeatureFactory,
- * });
- *
- * const combinedFeature = productCombinedFactory({
- *     actionsGroupKey: '[Combined]',
- *     featureSelector: 'combined',
- *   });
- *
- *   combinedFeature.actions.client.loadClients();
- *   combinedFeature.actions.product.loadProducts();
- */
-export declare function combineEntityFeatures<T extends {
-    [key: string]: EntityFeatureFactory<any, any>;
-}, K extends keyof T, State extends {
-    [P in K]: ExtractStateType<ReturnType<T[P]>>;
-}, A extends {
-    [P in K]: ExtractActionsType<ReturnType<T[P]>>;
-}, S extends {
-    [P in K]: FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[P]>>>;
-}, R extends (config: Config<State>) => {
-    actions: A;
-    selectors: S;
-    reducer: (state: State, action: ActionType<any>) => State;
-    effects: Type<any>[];
-    initialState: State;
-}>(traitFactoriesMap: T): R;
-/**
- * Mix a map entityFeatureFactories into one, different from combine the actions and selectors a mix, not group by key like in combine, the keys are still use
- * internal in the reducers and selector to separate the state
- * @param traitFactoriesMap
- *
- * @example
- *
- * const clientsFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'client', entitiesName: 'clients' },
- *   addLoadEntitiesTrait<Client>(),
- *   addCrudEntitiesTrait<Client>()
- * );
- *
- * const productOrderFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'productOrder' },
- *   addLoadEntitiesTrait<ProductOrder>(),
- *   addSelectEntitiesTrait<ProductOrder>()
- * );
- *
- * const productFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'product' },
- *   addLoadEntitiesTrait<Product>(),
- *   addSelectEntitiesTrait<Product>()
- * );
- *
- * const productMixedFactory = mixEntityFeatures({
- *   products: productFeatureFactory,
- *   productOrders: productOrderFeatureFactory,
- *   clients: clientsFeatureFactory,
- * });
- *
- * const mixedFeature = productMixedFactory({
- *     actionsGroupKey: '[Mixed]',
- *     featureSelector: 'mixed',
- *   });
- * mixedFeature.actions.loadClients();
- * mixedFeature.actions.loadProducts();
- *
- */
-export declare function mixEntityFeatures<T extends {
-    [key: string]: EntityFeatureFactory<any, any>;
-}, K extends keyof T, State extends {
-    [P in K]: ExtractStateType<ReturnType<T[P]>>;
-}, A extends TraitActions & UnionToIntersection<ExtractActionsType<ReturnType<T[K]>>>, S extends TraitSelectors<any> & UnionToIntersection<FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[K]>>>>, R extends EntityFeatureFactory<any, any, State, A, S>>(traitFactoriesMap: T): R;
-/**
- * Combines targetTraitFactory with the traitFactoriesMap using the keys as props for the targetTraitFactory state,
- * and grouping the combined actions by key
- * @param targetTraitFactory
- * @param traitFactoriesMap
- *
- * @example
- *
- * const clientsFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'client', entitiesName: 'clients' },
- *   addLoadEntitiesTrait<Client>(),
- *   addCrudEntitiesTrait<Client>()
- * );
- *
- * const productOrderFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'productOrder' },
- *   addLoadEntitiesTrait<ProductOrder>(),
- *   addSelectEntitiesTrait<ProductOrder>()
- * );
- *
- * const productFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'product' },
- *   addLoadEntitiesTrait<Product>(),
- *   addSelectEntitiesTrait<Product>()
- * );
- *
- * const productAddEntityPropertiesFactory = addEntityFeaturesProperties(
- *   productFeatureFactory,
- *   {
- *     productOrders: productOrderFeatureFactory,
- *     clients: clientsFeatureFactory,
- *   }
- * );
- *
- * const combinedFeature = productAddEntityPropertiesFactory({
- *     actionsGroupKey: '[addEntityFeatures]',
- *     featureSelector: 'addEntityFeatures',
- *   });
- *
- *   combinedFeature.actions.loadProducts();
- *   combinedFeature.actions.clients.loadClients();
- *   combinedFeature.actions.productOrders.loadProductOrders();
- */
-export declare function addEntityFeaturesProperties<F extends EntityFeatureFactory<any, any>, T extends {
-    [key: string]: EntityFeatureFactory<any, any, any, any, any>;
-}, K extends keyof T, State extends ExtractStateType<ReturnType<F>> & {
-    [P in K]: ExtractStateType<ReturnType<T[P]>>;
-}, A extends ExtractActionsType<ReturnType<F>> & {
-    [P in K]: ExtractActionsType<ReturnType<T[P]>>;
-}, S extends FeatureSelectors<State, ExtractSelectorsType<ReturnType<F>>> & {
-    [P in K]: FeatureSelectors<State, ExtractSelectorsType<ReturnType<T[P]>>>;
-}, R extends (config: Config<State>) => {
-    actions: A;
-    selectors: S;
-    reducer: (state: State, action: ActionType<any>) => State;
-    effects: Type<any>[];
-    initialState: State;
-}>(targetTraitFactory: F, traitFactoriesMap: T): R;
-/**
- * Helper function to create an implementation  a TraitFactory
- * @param f TraitFactory implementation
- */
-export declare function createTraitFactory<State = {}, A extends TraitActions = {}, S extends TraitSelectors<State> = {}, M extends TraitStateMutators<State> = {}, KEY extends string = string, C = unknown, KC extends AllTraitConfigs = KeyedConfig<KEY, C>>(f: {
-    key: KEY;
-    config?: C;
-    depends?: string[];
-    actions?: TraitActionsFactory<A, KC>;
-    selectors?: TraitSelectorsFactory<State, S, KC>;
-    initialState?: TraitInitialStateFactory<State, KC>;
-    mutators?: TraitStateMutatorsFactory<State, M, KC>;
-    reducer?: TraitReducerFactory<State, A, S, M, KC>;
-    effects?: TraitEffectsFactory<State, A, S, KC>;
-}): TraitFactory<State, A, S, M, KEY, C, KC>;
-/**
- * Helper function to combine selectors in components as map
- *
- * @example
- *
- * view = combineSelectors({
- *     products: ProductSelectors.selectProductsCurrentPage,
- *     isLoading: ProductSelectors.isLoadingProductsCurrentPage,
- *     selectedProduct: ProductSelectors.selectProductSelected,
- *     isLoadingCheckout: ProductSelectors.isLoadingCheckout,
- *     selectedSort: ProductSelectors.selectProductsSort,
- *     filters: ProductSelectors.selectProductsFilter,
- *   });
- * @param t
- */
-export declare function combineSelectors<T extends {
-    [k: string]: MemoizedSelector<any, any>;
-}>(t: T): MemoizedSelector<any, {
-    [j in keyof T]: ReturnType<T[j]>;
-}>;

package/local-store/disable-local-trait-effects.token.d.ts

@@ -1,6 +0,0 @@
-import { InjectionToken } from '@angular/core';
-/**
- * @ignore
- * @internal
- */
-export declare const DISABLE_LOCAL_TRAIT_EFFECTS: InjectionToken<boolean>;

package/local-store/index.d.ts

@@ -1,2 +0,0 @@
-export * from './traits-local-store';
-export * from './disable-local-trait-effects.token';

package/local-store/traits-local-store.d.ts

@@ -1,106 +0,0 @@
-import { Injector, OnDestroy } from '@angular/core';
-import { BaseEntityFeatureFactory } from '../model';
-import { TraitEffect } from '../trait-effect';
-import * as i0 from "@angular/core";
-/**
- * Builds traitFactory and registers effects and reducers with
- * a generated component id, returns build actions and selectors
- * and a destroy method that will unergister the effects and reducers
- * when called, and a addEffect which can be use to register extra effects
- *
- * Used inside TraitsLocalStore, can be used to create your
- * own Component Service without extending TraitsLocalStore
- * @param injector
- * @param componentName
- * @param traitFactory
- */
-export declare function buildLocalTraits<State, F extends BaseEntityFeatureFactory<any, any, any>>(injector: Injector, componentName: string, traitFactory: F): {
-    destroy: () => void;
-    actions: any;
-    selectors: any;
-    addEffects(localEffect: TraitEffect): void;
-};
-export interface Type<T> extends Function {
-    new (...args: any[]): T;
-}
-export interface LocalTraitsConfig<F extends BaseEntityFeatureFactory<any, any, any>> {
-    componentName: string;
-    traitsFactory: F;
-}
-/**
- * Class used to create local traits service, receives a trait factory, which will be
- * built and its reducers and effect register using a dynamic id when the service is built
- * and get destroyed when the onDestroy lifecycle method of the service is called, if the service
- * has effects this.traits.addEffects(this) should be call in the constructor
- *
- * @example
- * const productFeatureFactory = createEntityFeatureFactory(
- *   { entityName: 'product' },
- *   addLoadEntitiesTrait<Product>(),
- *   addSelectEntityTrait<Product>(),
- * );
- *
- * Injectable()
- * export class ProductsLocalTraits extends TraitsLocalStore<
- *   typeof productFeatureFactory
- * > {
- *   loadProducts$ = createEffect(() =>
- *     this.actions$.pipe(
- *       ofType(this.localActions.loadProducts),
- *       switchMap(() =>
- *         //call your service to get the products data
- *         this.productService.getProducts().pipe(
- *           map((res) =>
- *             this.localActions.loadProductsSuccess({ entities: res.resultList })
- *           ),
- *           catchError(() => of(this.localActions.loadProductsFail()))
- *         )
- *       )
- *     )
- *   );
- *
- *   constructor(injector: Injector, private productService: ProductService) {
- *     super(injector);
- *     this.traits.addEffects(this); // IMPORTANT! add this line if the service has effects
- *   }
- *
- *   setup(): LocalTraitsConfig<typeof productFeatureFactory> {
- *     return {
- *       componentName: 'ProductsPickerComponent',
- *       traitsFactory: productFeatureFactory,
- *     };
- *   }
- * }
- *
- * // use in component later
- *
- * Component({
- *   selector: 'some-component',
- *   template: `<div> some content</div> `,
- *   providers: [ProductsLocalTraits],
- *   changeDetection: ChangeDetectionStrategy.OnPush,
- * })
- * export class ProductSelectDialogComponent implements OnInit {
- *   constructor(private store: Store, private traits: ProductsLocalTraits) {}
- *
- *   ngOnInit() {
- *     this.store.dispatch(this.traits.localActions.loadProducts());
- *   }
- * }
- */
-export declare abstract class TraitsLocalStore<F extends BaseEntityFeatureFactory<any, any, any>> extends TraitEffect implements OnDestroy {
-    traits: {
-        actions: ReturnType<F>['actions'];
-        selectors: ReturnType<F>['selectors'];
-        destroy: () => void;
-        addEffects: (localEffect: TraitEffect) => void;
-    };
-    localActions: ReturnType<F>['actions'];
-    localSelectors: ReturnType<F>['selectors'];
-    private injector;
-    constructor();
-    abstract setup(): LocalTraitsConfig<F>;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TraitsLocalStore<any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TraitsLocalStore<any>>;
-}

package/model.d.ts

@@ -1,103 +0,0 @@
-import { Type } from '@angular/core';
-import { Action, ActionType, MemoizedSelector } from '@ngrx/store';
-import { ActionCreator, Selector, SelectorWithProps } from '@ngrx/store/src/models';
-import { TraitEffect } from './trait-effect';
-export type TraitActions = {
-    [key: string]: ActionCreator<string, (...args: any[]) => Action<string>>;
-};
-export type TraitSelectors<State> = {
-    [key: string]: Selector<State, any> | SelectorWithProps<State, any, any> | MemoizedSelector<State, any>;
-};
-export type TraitStateMutators<State> = {
-    [key: string]: <S extends State>(...arg: any[]) => S;
-};
-export interface BaseFeatureTraits<State = any, A = any, S = any> {
-    actions: A;
-    selectors: S;
-    reducer: (state: State, action: ActionType<any>) => State;
-    effects: Type<any>[];
-    initialState: State;
-}
-export type FeatureTraits<State, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>> = BaseFeatureTraits<State, A, FeatureSelectors<State, S>>;
-export type BaseEntityFeatureFactory<State, A, S> = (config: Config<State>) => BaseFeatureTraits<State, A, S>;
-export type EntityFeatureFactory<EntityName extends string | undefined, EntitiesName extends string = `${EntityName}s`, State = any, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>> = (config: Config<State>) => FeatureTraits<State, EntityName extends string ? ReplaceEntityNames<A, EntityName, EntitiesName> : A, EntityName extends string ? ReplaceEntityNames<S, EntityName, EntitiesName> : S>;
-export type Config<State, F extends MemoizedSelector<object, State> = MemoizedSelector<object, State>> = {
-    actionsGroupKey: string;
-    featureSelector: F | string;
-};
-export type FeatureSelectors<State, S extends TraitSelectors<State>> = {
-    [key in keyof S]: MemoizedSelector<object, ReturnType<S[key]>, S[key]>;
-};
-export type AllTraitConfigs = {
-    [id: string]: any;
-};
-export type TraitActionsFactory<A extends TraitActions = TraitActions, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitActionsFactoryConfig<C>) => A;
-export type TraitActionsFactoryConfig<C extends AllTraitConfigs = AllTraitConfigs> = {
-    actionsGroupKey: string;
-    entityName: string;
-    entitiesName: string;
-    allConfigs: C;
-};
-export type TraitSelectorsFactory<State = unknown, S extends TraitSelectors<State> = TraitSelectors<State>, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitSelectorsFactoryConfig<C>) => S;
-export type TraitSelectorsFactoryConfig<C extends AllTraitConfigs = AllTraitConfigs> = {
-    previousSelectors: TraitSelectors<unknown> | undefined;
-    allConfigs: C;
-};
-export type TraitInitialStateFactory<State = unknown, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitInitialStateFactoryConfig<C>) => State;
-export type TraitInitialStateFactoryConfig<C extends AllTraitConfigs = AllTraitConfigs> = {
-    previousInitialState: any;
-    allConfigs: C;
-};
-export type TraitStateMutatorsFactory<State = unknown, M extends TraitStateMutators<State> = TraitStateMutators<State>, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitStateMutatorsFactoryConfig<C>) => M;
-export type TraitStateMutatorsFactoryConfig<C extends AllTraitConfigs = AllTraitConfigs> = {
-    allSelectors: TraitSelectors<any>;
-    previousMutators: TraitStateMutators<unknown> | undefined;
-    allConfigs: C;
-};
-export type TraitReducerFactory<State = unknown, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>, M extends TraitStateMutators<State> = TraitStateMutators<State>, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitReducerFactoryConfig<State, A, S, M, C>) => (initialState: State, action: Action) => State;
-export type TraitReducerFactoryConfig<State = unknown, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>, M extends TraitStateMutators<State> = TraitStateMutators<State>, C extends AllTraitConfigs = AllTraitConfigs> = {
-    initialState: State;
-    allActions: A;
-    allSelectors: S;
-    allMutators: M;
-    allConfigs: C;
-};
-export type TraitEffectsFactory<State = unknown, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>, C extends AllTraitConfigs = AllTraitConfigs> = (options: TraitEffectsFactoryConfig<State, A, S, C>) => Type<TraitEffect>[];
-export type TraitEffectsFactoryConfig<State = unknown, A extends TraitActions = TraitActions, S extends TraitSelectors<State> = TraitSelectors<State>, C extends AllTraitConfigs = AllTraitConfigs> = {
-    allActions: A;
-    allSelectors: S;
-    allConfigs: C;
-};
-export type KeyedConfig<KEY extends string, C> = Record<string, any> & {
-    [K in KEY]?: C;
-};
-export interface TraitFactory<State = any, A extends TraitActions = any, S extends TraitSelectors<State> = any, M extends TraitStateMutators<State> = any, KEY extends string = string, C = any, KC extends AllTraitConfigs = KeyedConfig<KEY, C>> {
-    key: KEY;
-    config?: C;
-    depends?: string[];
-    actions: TraitActionsFactory<A, KC>;
-    selectors: TraitSelectorsFactory<State, S, KC>;
-    initialState: TraitInitialStateFactory<State, KC>;
-    mutators: TraitStateMutatorsFactory<State, M, KC>;
-    reducer?: TraitReducerFactory<State, A, S, M, KC>;
-    effects?: TraitEffectsFactory<State, A, S, KC>;
-}
-type ExtractArrayElementTypes<X> = X extends ReadonlyArray<infer T> ? T : never;
-export type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
-export type ExtractStateType<T> = T extends TraitFactory<infer State> ? State : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractStateType<ExtractArrayElementTypes<T>>> : T extends BaseFeatureTraits<infer State> ? State : never;
-export type ExtractActionsType<T> = T extends TraitFactory<any, infer A> ? A : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractActionsType<ExtractArrayElementTypes<T>>> : T extends BaseFeatureTraits<any, infer A> ? A : never;
-export type ExtractSelectorsType<T> = T extends TraitFactory<any, any, infer S> ? S : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractSelectorsType<ExtractArrayElementTypes<T>>> : T extends BaseFeatureTraits<any, any, infer S> ? S : never;
-export type ExtractMutatorsType<T> = T extends TraitFactory<any, any, any, infer M> ? M : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractMutatorsType<ExtractArrayElementTypes<T>>> : never;
-export type ExtractKeyedConfigType<T> = T extends TraitFactory<any, any, any, any, infer KEY, infer C> ? KeyedConfig<KEY, C> : T extends ReadonlyArray<TraitFactory> ? UnionToIntersection<ExtractKeyedConfigType<ExtractArrayElementTypes<T>>> : never;
-export type PrefixProps<T, P extends string> = {
-    [K in keyof T as `${P}${Capitalize<string & K>}`]: T[K];
-};
-export type PostfixProps<T, P extends string> = {
-    [K in keyof T as `${Uncapitalize<string & K>}${Capitalize<P>}`]: T[K];
-};
-type Replace<Target extends string, FindKey extends string, FindKey2 extends string, ReplaceKey extends string, ReplaceKey2 extends string> = Target extends `${infer Prefix}${FindKey}${infer Postfix}` ? `${Prefix}${Capitalize<ReplaceKey>}${Postfix}` : Target extends `${infer Prefix}${FindKey2}${infer Postfix}` ? `${Prefix}${Capitalize<ReplaceKey2>}${Postfix}` : Target;
-export type ReplaceProps<Target, FindKey extends string, FindKey2 extends string, ReplaceKey extends string, ReplaceKey2 extends string> = {
-    [Prop in keyof Target as Replace<string & Prop, FindKey, FindKey2, ReplaceKey, ReplaceKey2>]: Target[Prop];
-};
-export type ReplaceEntityNames<T, EntityName extends string, EntitiesName extends string> = ReplaceProps<T, 'Entities', 'Entity', EntitiesName, EntityName>;
-export {};

package/testing/provide-mock-local-traits.d.ts

@@ -1,8 +0,0 @@
-import { EntityFeatureFactory, TraitsLocalStore } from '@ngrx-traits/core';
-import { Provider, Type } from '@angular/core';
-export declare function provideMockLocalTraits<T extends TraitsLocalStore<EntityFeatureFactory<any, any>>>({ traitFactory, selectors, }: {
-    traitFactory: Type<T>;
-    selectors?: {
-        [key in keyof T['localSelectors']]?: ReturnType<T['localSelectors'][key]>;
-    };
-}): Provider[];

package/trait-effect.d.ts

@@ -1,15 +0,0 @@
-import { Actions, OnIdentifyEffects, OnRunEffects } from '@ngrx/effects';
-import { Store } from '@ngrx/store';
-import { Observable } from 'rxjs';
-import * as i0 from "@angular/core";
-export declare class TraitEffect implements OnIdentifyEffects, OnRunEffects {
-    private name;
-    componentId: string;
-    protected actions$: Actions<any>;
-    protected store: Store<any>;
-    ngrxOnIdentifyEffects(): string;
-    ngrxOnRunEffects(resolvedEffects$: Observable<any>): Observable<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TraitEffect, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TraitEffect>;
-}
-export declare function getDestroyActionName(id: string): string;

package/util.d.ts

@@ -1,43 +0,0 @@
-import { ReducerTypes } from '@ngrx/store/src/reducer_creator';
-import { ActionCreator } from '@ngrx/store/src/models';
-import { ActionType } from '@ngrx/store';
-export declare function insertIf<State>(condition: any, getElement: () => ReducerTypes<State, ActionCreator[]>): ReducerTypes<State, ActionCreator[]>[];
-export declare function toMap(a: Array<string | number>): {
-    [key: string]: boolean;
-};
-export declare function capitalize(name: string): string;
-export declare function camelCaseToSentence(text: string): string;
-/**
- * Set propertyReducer in sourceReducer in a property of the source state,
- * @param sourceReducer
- * @param property
- * @param propertyReducer
- *
- * @example
- *
- * const newReducer = setPropertyReducer(productsReducer, 'selectedProduct', selectedProductReducer)
- */
-export declare function setPropertyReducer<State, P extends keyof State>(sourceReducer: (state: State, action: ActionType<any>) => State, property: P, propertyReducer: (state: State[P], action: ActionType<any>) => State[P]): (state: State, action: ActionType<any>) => State;
-/**
- * Set propertyReducers in sourceReducer each in a property of the source state,
- * @param sourceReducer
- * @param property
- * @param propertyReducer
- *
- * @example
- *
- * const newReducer = setPropertyReducer(productsReducer,
- * {
- *    selectedProduct: selectedProductReducer
- *    favoriteProduct: favoriteProductReducer
- * })
- */
-export declare function setPropertiesReducer<State, P extends keyof State>(sourceReducer: (state: State, action: ActionType<any>) => State, propertiesReducers: {
-    [key in P]: (state: State[P], action: ActionType<any>) => State[P];
-}): (state: State, action: ActionType<any>) => State;
-/**
- * joins two reducers so the work in the same state
- * @param firstReducer
- * @param secondReducer
- */
-export declare function joinReducers<State>(firstReducer: (state: State, action: ActionType<any>) => State, secondReducer: (state: any, action: ActionType<any>) => any): (state: State, action: ActionType<any>) => State;